ouin ouin ouin

Author: GhostScissors

Emote_GasStation_JunoVersion_Loop.rada

@@ -0,0 +1,14 @@
+#pragma once
+#include <cstdint>
+
+struct FDecodeResult
+{
+    int32_t shii;
+    
+    // Number of bytes of compressed data consumed
+    int32_t NumCompressedBytesConsumed;
+    // Number of bytes produced
+    int32_t NumPcmBytesProduced;
+    // Number of frames produced.
+    int32_t NumAudioFramesProduced;
+};

RADADecoder/FDecodeResult.h

@@ -1,8 +1,14 @@
 #include "FRadAudioInfo.h"
+
+#include <fstream>
+#include <iostream>
+
 #include "SDK/Include/rada_decode.h"
 
 #include <random>
 
+#include "FDecodeResult.h"
+
 bool FRadAudioInfo::ParseHeader(const uint8_t* InSrcBufferData, uint32_t InSrcBufferDataSize, const FSoundQualityInfo* QualityInfo)
 {
     const RadAFileHeader* FileHeader = RadAGetFileHeader(InSrcBufferData, InSrcBufferDataSize);
@@ -46,13 +52,13 @@ bool FRadAudioInfo::CreateDecoder(const uint8_t* SrcBufferData, uint32_t SrcBuff
 {
     if (SrcBufferOffset != 0)
         return false;
-
-    const RadAFileHeader* FileHeader = RadAGetFileHeader(SrcBufferData, SrcBufferDataSize);
+    
+    const RadAFileHeader* FileHeader = MIRARadAGetFileHeader_1(SrcBufferData, SrcBufferDataSize);
     if (FileHeader == nullptr)
         return false;
-
+    
     uint32_t DecoderMemoryNeeded = 0;
-    if (RadAGetMemoryNeededToOpen(SrcBufferData, SrcBufferDataSize, &DecoderMemoryNeeded) != 0)
+    if (MIRARadAGetMemoryNeededToOpen_1(SrcBufferData, SrcBufferDataSize, &DecoderMemoryNeeded) != 0)
     {
         printf("Invalid/insufficient data in FRadAudioInfo::CreateDecoder - bad buffer passed / bad cook? Size = %d", SrcBufferDataSize);
         if (SrcBufferDataSize > 8)
@@ -73,7 +79,7 @@ bool FRadAudioInfo::CreateDecoder(const uint8_t* SrcBufferData, uint32_t SrcBuff
 
     Container = Decoder->Container();
 
-    if (RadAOpenDecoder(SrcBufferData, SrcBufferDataSize, Container, DecoderMemoryNeeded) == 0)
+    if (MIRARadAOpenDecoder_1(SrcBufferData, SrcBufferDataSize, Container, DecoderMemoryNeeded) == 0)
     {
         printf("Failed to open decoder, likely corrupted data.");
         free(RawMemory);
@@ -85,67 +91,143 @@ bool FRadAudioInfo::CreateDecoder(const uint8_t* SrcBufferData, uint32_t SrcBuff
     return true;
 }
 
-bool FRadAudioInfo::Decode(const uint8_t* CompressedData, const int32_t CompressedDataSize, uint8_t* OutPCMData, const int32_t OutputPCMDataSize, uint32_t NumChannels, RadAudioDecoderHeader* Decoder)
+FDecodeResult FRadAudioInfo::Decode(uint8_t* CompressedData, const int32_t CompressedDataSize, uint8_t* OutPCMData, const int32_t OutputPCMDataSize, uint32_t NumChannels, RadAudioDecoderHeader* Decoder)
 {
     uint32_t SampleStride = NumChannels * sizeof(int16_t); // constexpr uint32 MONO_PCM_SAMPLE_SIZE = sizeof(int16);
     uint32_t RemnOutputFrames = OutputPCMDataSize / SampleStride;
     uint32_t RemnCompressedDataSize = CompressedDataSize;
     const uint8_t* CompressedDataEnd = CompressedData + CompressedDataSize;
 
     std::vector<float> DeinterleavedDecodeBuffer;
+    std::vector<uint8_t> OutputReservoir;
 
     while (RemnOutputFrames)
     {
         // Drain the output reservoir before attempting a decode.
         if (Decoder->OutputReservoirReadFrames < Decoder->OutputReservoirValidFrames)
         {
-            
+            uint32_t AvailableFrames = Decoder->OutputReservoirReadFrames - Decoder->OutputReservoirValidFrames;
+            uint32_t CopyFrames = std::min(AvailableFrames, RemnOutputFrames);
+
+            uint32_t CopyByteCount = SampleStride * CopyFrames;
+            uint32_t CopyOffset = SampleStride * Decoder->OutputReservoirReadFrames;
+            memcpy(OutPCMData, OutputReservoir.data() + CopyOffset, CopyByteCount);
+
+            Decoder->OutputReservoirReadFrames += CopyFrames;
+            RemnOutputFrames -= CopyFrames;
+            OutPCMData += CopyByteCount;
+
+            if (RemnOutputFrames == 0)
+                break;
         }
 
         if (RemnCompressedDataSize == 0)
-            return false;
-
-        // This shit is bs if we pass the data from the offset it fucking fails but if we pass the fucker with pos 0 it passes but then is corrupted apparently
-        // Either this fucker needs its pos to be increased manually or something, but I highly doubt it
-        // But the container shit is correct, so I don't even fucking know now
+            break;
+        
         uint32_t CompressedBytesNeeded = 0;
         RadAExamineBlockResult BlockResult = RadAExamineBlock(Decoder->Container(), CompressedData, RemnCompressedDataSize, &CompressedBytesNeeded);
-
-        CompressedData += sizeof(RadAContainer*);
-
+        
         if (BlockResult != RadAExamineBlockResult::Valid)
         {
             printf("Invalid block in FRadAudioInfo::Decode: Result = %d, RemnSize = %d \n", BlockResult, RemnCompressedDataSize);
             if (RemnCompressedDataSize >= 8)
                 printf("First 8 bytes of buffer: 0x%02x 0x%02x 0x%02x 0x%02x:0x%02x 0x%02x 0x%02x 0x%02x \n", CompressedData[0], CompressedData[1], CompressedData[2], CompressedData[3], CompressedData[4], CompressedData[5], CompressedData[6], CompressedData[7]);
 
-            return false;
+            break;
         }
 
-        // RadAudio outputs deinterleaved 32 bit float buffers - we don't want to carry around
-        // those buffers all the time and rad audio uses a pretty healthy amount of stack already
+        // RadAudio outputs deinterleaved 32-bit float buffers - we don't want to carry around
+        // those buffers all the time and rad audio uses a pretty healthy amount of stack already,
         // so we drop these in the temp buffers.
-        if (DeinterleavedDecodeBuffer.size() == 0)
+        if (DeinterleavedDecodeBuffer.empty())
             DeinterleavedDecodeBuffer = std::vector<float>(RadADecodeBlock_MaxOutputFrames * NumChannels);
-
+        
         size_t CompressedDataConsumed = 0;
         int16_t DecodeResult = RadADecodeBlock(Decoder->Container(), CompressedData, RemnCompressedDataSize, DeinterleavedDecodeBuffer.data(), RadADecodeBlock_MaxOutputFrames, &CompressedDataConsumed);
 
         if (DecodeResult == RadADecodeBlock_Error)
         {
-            printf("Failed to decode block that passed validation checks, corrupted buffer?");
-            return false;
+            printf("Failed to decode block that passed validation checks, corrupted buffer? \n");
+            return FDecodeResult();
         }
         else if (DecodeResult == RadADecodeBlock_Done)
         {
-            return true;
+            break;
         }
-
+        
         CompressedData += CompressedDataConsumed;
         RemnCompressedDataSize -= CompressedDataConsumed;
+
+        int16_t DecodeResultOffset = 0;
+
+        if (Decoder->ConsumeFrameCount)
+        {
+            int16_t ConsumedThisTime = DecodeResult;
+            if (Decoder->ConsumeFrameCount < DecodeResult)
+            {
+                ConsumedThisTime = (int16_t)Decoder->ConsumeFrameCount;
+            }
+
+            if (ConsumedThisTime)
+            {
+                DecodeResultOffset = ConsumedThisTime;
+                DecodeResult -= ConsumedThisTime;
+            }
+            Decoder->ConsumeFrameCount -= ConsumedThisTime;
+        }
+
+        if (DecodeResult == 0)
+            continue;
+
+        int16_t* InterleaveDestination = (int16_t*)OutPCMData;
+        if (RemnOutputFrames < RadADecodeBlock_MaxOutputFrames)
+        {
+            if (OutputReservoir.empty())
+                OutputReservoir.reserve(RadADecodeBlock_MaxOutputFrames * SampleStride);
+
+            InterleaveDestination = (int16_t*)OutputReservoir.data();
+        }
+
+        for (int32_t ChannelIdx = 0; ChannelIdx < NumChannels; ChannelIdx++)
+        {
+            const float* InBuffer = DeinterleavedDecodeBuffer.data() + RadADecodeBlock_MaxOutputFrames*ChannelIdx + DecodeResultOffset;
+			
+            for (int32_t SampleIdx = 0; SampleIdx < DecodeResult; SampleIdx++)
+            {
+                float InBufferFloat = InBuffer[SampleIdx] * 32768.0f;
+                if (InBufferFloat > 32767)
+                {
+                    InBufferFloat = 32767;
+                }
+                else if (InBufferFloat < -32768)
+                {
+                    InBufferFloat = -32768;
+                }
+
+                InterleaveDestination[ChannelIdx + (SampleIdx * NumChannels)] = (int16_t)InBufferFloat;
+            }
+        }
+
+        if (InterleaveDestination == (int16_t*)OutputReservoir.data())
+        {
+            Decoder->OutputReservoirValidFrames = DecodeResult;
+            Decoder->OutputReservoirReadFrames = 0;
+        }
+        else
+        {
+            RemnOutputFrames -= DecodeResult;
+            OutPCMData += DecodeResult * SampleStride;
+        }
     }
 
-    return true;
+    FDecodeResult Result;
+
+    Result.shii = OutputPCMDataSize - RemnOutputFrames;
+    Result.NumPcmBytesProduced = OutputPCMDataSize - (RemnOutputFrames * SampleStride);
+    Result.NumAudioFramesProduced = Result.NumPcmBytesProduced / SampleStride;
+    Result.NumCompressedBytesConsumed = CompressedDataSize - RemnCompressedDataSize;
+    
+    return Result;
 }
 
 

RADADecoder/FRadAudioInfo.cpp

@@ -1,17 +1,20 @@
 #pragma once
 #include <cstdint>
 
+#include "FDecodeResult.h"
 #include "FSoundQualityInfo.h"
 #include "RadAudioDecoderHeader.h"
 
 class FRadAudioInfo
 {
 public:
     static bool ParseHeader(const uint8_t* InSrcBufferData, uint32_t InSrcBufferDataSize, const FSoundQualityInfo* QualityInfo);
-    static bool CreateDecoder(const uint8_t* SrcBufferData, uint32_t SrcBufferDataSize, RadAudioDecoderHeader*& Decoder, uint8_t*& RawMemory, uint32_t&
-                              SrcBufferOffset, RadAContainer*& Container);
-    static bool Decode(const uint8_t* CompressedData, int32_t CompressedDataSize, uint8_t* OutPCMData, int32_t OutputPCMDataSize, uint32_t
-                   NumChannels, RadAudioDecoderHeader* Decoder);
+    static bool CreateDecoder(const uint8_t* SrcBufferData, uint32_t SrcBufferDataSize, RadAudioDecoderHeader*& Decoder, uint8_t*& RawMemory, uint32_t
+                              & SrcBufferOffset, RadAContainer*& Container);
+    static FDecodeResult Decode(uint8_t* CompressedData, int32_t CompressedDataSize, uint8_t* OutPCMData, int32_t OutputPCMDataSize, uint32_t
+                       NumChannels, RadAudioDecoderHeader* Decoder);
+
+    static int32_t SeekTableSize(const uint8_t);
 
 private:
     template <typename T>

RADADecoder/FRadAudioInfo.h

@@ -5,12 +5,21 @@
 
 #include "FRadAudioInfo.h"
 #include "FSoundQualityInfo.h"
+#include "WaveHeader.h"
 
 int main()
 {
-    std::string inputFilePath = R"(D:\Programming\RADADecoder\Emote_GasStation_JunoVersion_Loop.rada)";
+    bool verbose = true;
+
+    //std::string inputFilePath = R"(D:\Programming\RadA-Decoder\Emote_GasStation_JunoVersion_Loop.rada)";
+    //std::ifstream inputFile(inputFilePath, std::ios::binary);
+    
+    std::string inputFilePath = R"(D:\Leaking Tools\FModel\Output\Exports\FortniteGame\Plugins\GameFeatures\BRCosmetics\Content\Sounds\MusicPacks\BuffCat_Comic\Drop_In_MusicPack_Loop.rada)";
     std::ifstream inputFile(inputFilePath, std::ios::binary);
 
+    std::string outFilePath = R"(D:\Programming\RadA-Decoder\Output.wav)";
+    std::ofstream outFile(outFilePath, std::ios::binary);
+
     std::shared_ptr<uint8_t> inputData;
 
     inputFile.seekg(0, std::ios::end);
@@ -48,20 +57,19 @@ int main()
 
     bool inSkip = false;
     size_t dstOffset = 0;
-
-    for (size_t i = 0; i < inputDataSize; i++)
+    
+    for (size_t i = srcBufferOffset; i < inputDataSize; i++)
     {
         if (!inSkip && i + 4 < inputDataSize && std::memcmp(&inputData.get()[i], "SEEK", 4) == 0)
         {
             inSkip = true;
             i += 3;
+
         }
-        else if (inSkip && i + 2 < inputDataSize && inputData.get()[i] == 0x99 && inputData.get()[i + 1] == 0x99)
+        else if (inSkip && i + 2 < inputDataSize && inputData.get()[i] == 0x55)
         {
             inSkip = false;
-            compressedData.get()[dstOffset++] = 0x99;
-            compressedData.get()[dstOffset++] = 0x99;
-            i += 1; // Skip 0x9999
+            compressedData.get()[dstOffset++] = 0x55;
         }
         else if (!inSkip)
         {
@@ -70,11 +78,37 @@ int main()
     }
 
     uint8_t* OutPCMData = (uint8_t*)malloc(audioInfo.SampleDataSize);
-    if (!FRadAudioInfo::Decode(compressedData.get(), dstOffset, OutPCMData, audioInfo.SampleDataSize, audioInfo.NumChannels, decoder))
-    {
-        std::cerr << "Failed to decode RADA file" << '\n';
-        return 0;
-    }
+    auto result = FRadAudioInfo::Decode(compressedData.get(), dstOffset, OutPCMData, audioInfo.SampleDataSize, audioInfo.NumChannels, decoder);
+
+    WaveHeader header = {0};
+
+    memcpy(header.riff_tag, "RIFF", 4);
+    memcpy(header.wave_tag, "WAVE", 4);
+    memcpy(header.fmt_tag, "fmt ", 4);
+    memcpy(header.data_tag, "data", 4);
+    
+    header.sample_rate = audioInfo.SampleRate;
+    header.num_channels = audioInfo.NumChannels;
+    header.riff_length = result.shii + sizeof(WaveHeader) - 8;
+    header.data_length = result.shii;
+
+    int bits_per_sample = 16;
+    
+    header.fmt_length = 16;
+    header.audio_format = 1;
+    header.byte_rate = header.num_channels * header.sample_rate * bits_per_sample / 8;
+    header.block_align = header.num_channels * bits_per_sample / 8;
+    header.bits_per_sample = bits_per_sample;
+    
+    outFile.write(reinterpret_cast<char*>(&header), sizeof(header));
+    outFile.write(reinterpret_cast<char*>(OutPCMData), result.shii);
+    
+    std::cout << result.NumAudioFramesProduced << '\n';
+    std::cout << result.NumCompressedBytesConsumed << '\n';
+    std::cout << result.NumPcmBytesProduced << '\n';
+    
+    inputFile.close();
+    outFile.close();
 
     std::cout << "Shit worked" << '\n';
 }

RADADecoder/RADADecoder.cpp

@@ -147,8 +147,10 @@
     <ClCompile Include="SDK\Src\RadAudio\radaudio_mdct_test.cpp" />
     <ClCompile Include="SDK\Src\RadA\rada_decode.cpp" />
     <ClCompile Include="SDK\Src\RadA\rada_encode.cpp" />
+    <ClCompile Include="WaveHeader.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="FDecodeResult.h" />
     <ClInclude Include="FRadAudioInfo.h" />
     <ClInclude Include="FSoundQualityInfo.h" />
     <ClInclude Include="RadAudioDecoderHeader.h" />
@@ -179,6 +181,7 @@
     <ClInclude Include="SDK\Src\RadAudio\radaudio_sse.h" />
     <ClInclude Include="SDK\Src\RadAudio\rrbits.h" />
     <ClInclude Include="SDK\Src\RadAudio\rrCore.h" />
+    <ClInclude Include="WaveHeader.h" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

RADADecoder/RADADecoder.vcxproj

@@ -0,0 +1,4 @@
+#include "WaveHeader.h"
+
+#include <cstring>
+

RADADecoder/WaveHeader.cpp

@@ -0,0 +1,20 @@
+#pragma once
+
+struct WaveHeader
+{
+    char riff_tag[4];
+    int riff_length;
+    char wave_tag[4];
+    char fmt_tag[4];
+    int fmt_length;
+    short audio_format;
+    short num_channels;
+    int sample_rate;
+    int byte_rate;
+    short block_align;
+    short bits_per_sample;
+    char data_tag[4];
+    int data_length;
+};
+
+