I don't even know

Author: GhostScissors

RADADecoder/FRadAudioInfo.cpp

@@ -14,14 +14,19 @@ bool FRadAudioInfo::ParseHeader(const uint8_t* InSrcBufferData, uint32_t InSrcBu
 
     uint8_t NumChannels = FileHeader->channels;
 
+    // seek_table_entry_count is 16 bit, no overflow possible
     uint32_t SeekTableSize = FileHeader->seek_table_entry_count * sizeof(uint16_t);
     if (sizeof(RadAFileHeader) + SeekTableSize > InSrcBufferDataSize)
         return false;
 
+    // Store the offset to where the audio data begins.
     auto audioDataOffset = RadAGetBytesToOpen(FileHeader);
+
+    // Check we have all headers and seek table data in memory.
     if (audioDataOffset > InSrcBufferDataSize)
         return false;
 
+    // Write out the header info
     if (QualityInfo)
     {
         QualityInfo->SampleRate = RadASampleRateFromEnum(FileHeader->sample_rate);
@@ -36,7 +41,7 @@ bool FRadAudioInfo::ParseHeader(const uint8_t* InSrcBufferData, uint32_t InSrcBu
     return true;
 }
 
-bool FRadAudioInfo::CreateDecoder(const uint8_t* SrcBufferData, uint32_t SrcBufferDataSize, RadAudioDecoderHeader*& Decoder, uint8_t*& RawMemory, uint32_t& SrcBufferOffset, RadAContainer*& Container)
+bool FRadAudioInfo::CreateDecoder(const uint8_t *SrcBufferData, uint32_t SrcBufferDataSize, RadAudioDecoderHeader*& Decoder, uint8_t*& RawMemory, uint32_t& SrcBufferOffset)
 {
     if (SrcBufferOffset != 0)
         return false;
@@ -56,8 +61,73 @@ bool FRadAudioInfo::CreateDecoder(const uint8_t* SrcBufferData, uint32_t SrcBuff
     }
 
     uint32_t TotalMemory = DecoderMemoryNeeded + sizeof(RadAudioDecoderHeader);
+
+    //
+    // Allocate and save offsets
+    //
+    RawMemory = (uint8_t*)malloc(TotalMemory);
+    memset(RawMemory, 0, TotalMemory);
+
+    Decoder = (RadAudioDecoderHeader*)RawMemory;
+
+    RadAContainer* Container = Decoder->Container();
+
+    if (RadAOpenDecoder(SrcBufferData, SrcBufferDataSize, Container, DecoderMemoryNeeded) == 0)
+    {
+        printf("Failed to open decoder, likely corrupted data.");
+        free(RawMemory);
+        return false;
+    }
+
+    // Set our buffer at the start of the audio data.
+    SrcBufferOffset = RadAGetBytesToOpen(FileHeader);
+    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)
+{
+    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;
+
+    float* DeinterleavedDecodeBuffer = nullptr;
+
+    while (RemnOutputFrames)
+    {
+        // Drain the output reservoir before attempting a decode.
+        if (Decoder->OutputReservoirReadFrames < Decoder->OutputReservoirValidFrames)
+        {
+            
+        }
+
+        if (RemnCompressedDataSize == 0)
+            return false;
+
+        uint32_t CompressedBytesNeeded = 0;
+        RadAExamineBlockResult BlockResult = MIRARadAExamineBlock_1(Decoder->Container(), CompressedData, RemnCompressedDataSize, &CompressedBytesNeeded);
+
+        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;
+        }
+
+        // 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 == nullptr)
+            DeinterleavedDecodeBuffer = (float*)malloc(CompressedBytesNeeded);
+
+        size_t CompressedDataConsumed = 0;
+        int16_t DecodeResult = RadADecodeBlock(Decoder->Container(), CompressedData, RemnCompressedDataSize, DeinterleavedDecodeBuffer, RadADecodeBlock_MaxOutputFrames, &CompressedDataConsumed);
+    }
+    
+    return true;
+}
 
 template <typename T>
 bool FRadAudioInfo::MultiplyAndCheckForOverflow(T A, T B, T& OutResult)

RADADecoder/FRadAudioInfo.h

@@ -8,11 +8,10 @@ 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 void Decode(const uint8_t* compressedData, int32_t compressedDataSize, uint8_t* outPCMData, int32_t
-                       outputPCMDataSize, RadAudioDecoderHeader
-                       * decoder, int32_t numChannels);
+    static bool CreateDecoder(const uint8_t* SrcBufferData, uint32_t SrcBufferDataSize, RadAudioDecoderHeader*& Decoder, uint8_t*& RawMemory, uint32_t& SrcBufferOffset);
+
+    static bool Decode(const uint8_t* CompressedData, int32_t CompressedDataSize, uint8_t* OutPCMData, int32_t OutputPCMDataSize, uint32_t
+                       NumChannels, RadAudioDecoderHeader* Decoder);
 
 private:
     template <typename T>

RADADecoder/RADADecoder.cpp

@@ -36,16 +36,42 @@ int main()
     uint8_t* rawMemory = nullptr;
     RadAudioDecoderHeader* decoder = nullptr;
     uint32_t srcBufferOffset = 0;
-    RadAContainer* container = nullptr;
 
-    if (!FRadAudioInfo::CreateDecoder(inputData.get(), inputDataSize, decoder, rawMemory, srcBufferOffset, container))
+    if (!FRadAudioInfo::CreateDecoder(inputData.get(), inputDataSize, decoder, rawMemory, srcBufferOffset))
     {
         std::cerr << "Failed to create decoder." << '\n';
         return 0;
     }
+
+    std::unique_ptr<uint8_t> compressedData = std::unique_ptr<uint8_t>(new uint8_t[inputDataSize - srcBufferOffset]);
+
+    bool inSkip = false;
+    size_t dstOffset = 0;
+
+    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)
+        {
+            inSkip = false;
+            i += 1; // Skip 0x9999
+        }
+        else if (!inSkip)
+        {
+            compressedData.get()[dstOffset++] = inputData.get()[i];
+        }
+    }
+
+    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;
+    }
 
-    uint8_t* compressedData = inputData.get() + srcBufferOffset;
-    
-    uint8_t* data = nullptr;
     std::cout << "Shit worked" << '\n';
 }

RADADecoder/RadAudioDecoderHeader.h

@@ -17,6 +17,6 @@ struct RadAudioDecoderHeader
 
     RadAContainer* Container()
     {
-        return reinterpret_cast<RadAContainer*>(this + 1);
+        return (RadAContainer*)(this + 1);
     }
 };

RADADecoder/SDK/Src/RadA/rada_decode.cpp

@@ -1,6 +1,6 @@
 // Copyright Epic Games Tools, LLC. All Rights Reserved.
-#include "rada_decode.h"
-#include "radaudio_decoder.h"
+#include "../../Include/rada_decode.h"
+#include "../RadAudio/radaudio_decoder.h"
 
 #include <string.h>