Feature/capture (#4625)

* Add decoder

* Add a replay executable to consume the decoded content

Add file-processor.cpp/h where we implement the logic to process
the captured file block by block. Each block is:
function header + parameter buffer + function tailer + function
output[optional].

After reading one block, the block of data is sent to decoder module
to dispatch the corresponding API.

Add slang-decoder.cpp/h where we implement the logic to dispatch
the slang API according to the input block data.

- Rename api_callId.h to capture-format.h
- Renmae capture_utility.cpp to capture-utility.cpp
- Renmae capture_utility.h to capture-utility.h
- Change the #include file name accordingly.

* Reorganize source files structure

Move all the capture logic code into `capture` directory.
 - the capture code will be build with slang dll.

Move all the replay logic code into `relay` directoy.
 - the replay code is not part of slang dll, it will be built
   as a stand alone binary and link against slang dll.

Change the #include file names accordingly.

Add tools/slang-replay/main.cpp for the slang-replay stand alone
binary place holder. Will implement it later.

Update premake5.lua accordingly.

* Update cmake files

Update cmake files to change the build process for
capture and relay system.

 - capture component should be build with slang dll, so we
   should not include replay component.
 - replay component should be a separate executable tool, which
   should not include capture component.
 - In order to easy use our current cmake infrastructure, move
   the shared files to a `util` folder
 - change the header include path

* Redesgin the interfaces of consumers

Fix some issues in capture
Finish implementing all slang-decoder functions

* Fix the AppleClang build issue

* Address few comments

- Fix the weird indent issues.
- Correct the function name for CreateGlobalSession()
- Rename file-processor to captureFile-processor to be more specific.
- Use Slang::List instead of std::vector

* record/replay: name refactor change

Refactor the naming.

Change the name "encoder/capture" to "record".

1 files changed, 123 insertions, 0 deletions

diff --git a/source/slang-record-replay/record/parameter-recorder.cpp b/source/slang-record-replay/record/parameter-recorder.cpp
new file mode 100644
index 000000000..1c2fd9609
--- /dev/null
+++ b/source/slang-record-replay/record/parameter-recorder.cpp
@@ -0,0 +1,123 @@
+#include "parameter-recorder.h"
+
+namespace SlangRecord
+{
+    void ParameterRecorder::recordStruct(slang::SessionDesc const& desc)
+    {
+        recordUint64(desc.structureSize);
+        recordInt64(desc.targetCount);
+
+        for (SlangInt i = 0; i < desc.targetCount; i++)
+        {
+            recordStruct(desc.targets[i]);
+        }
+
+        recordUint32(desc.flags);
+        recordEnumValue(desc.defaultMatrixLayoutMode);
+        recordInt64(desc.searchPathCount);
+        for (SlangInt i = 0; i < desc.searchPathCount; i++)
+        {
+            recordString(desc.searchPaths[i]);
+        }
+
+        recordInt64(desc.preprocessorMacroCount);
+        for (SlangInt i = 0; i < desc.preprocessorMacroCount; i++)
+        {
+            recordStruct(desc.preprocessorMacros[i]);
+        }
+
+        recordBool(desc.enableEffectAnnotations);
+        recordBool(desc.allowGLSLSyntax);
+
+        recordUint32(desc.compilerOptionEntryCount);
+        for (uint32_t i = 0; i < desc.compilerOptionEntryCount; i++)
+        {
+            recordStruct(desc.compilerOptionEntries[i]);
+        }
+    }
+
+    void ParameterRecorder::recordStruct(slang::PreprocessorMacroDesc const& desc)
+    {
+        recordString(desc.name);
+        recordString(desc.value);
+    }
+
+    void ParameterRecorder::recordStruct(slang::CompilerOptionEntry const& entry)
+    {
+        recordEnumValue(entry.name);
+        recordStruct(entry.value);
+    }
+
+    void ParameterRecorder::recordStruct(slang::CompilerOptionValue const& value)
+    {
+        recordEnumValue(value.kind);
+        recordInt32(value.intValue0);
+        recordString(value.stringValue0);
+        recordString(value.stringValue1);
+    }
+
+    void ParameterRecorder::recordStruct(slang::TargetDesc const& targetDesc)
+    {
+        recordUint64(targetDesc.structureSize);
+        recordEnumValue(targetDesc.format);
+        recordEnumValue(targetDesc.profile);
+        recordEnumValue(targetDesc.flags);
+        recordEnumValue(targetDesc.floatingPointMode);
+        recordEnumValue(targetDesc.lineDirectiveMode);
+        recordBool(targetDesc.forceGLSLScalarBufferLayout);
+        recordUint32(targetDesc.compilerOptionEntryCount);
+        for (uint32_t i = 0; i < targetDesc.compilerOptionEntryCount; i++)
+        {
+            recordStruct(targetDesc.compilerOptionEntries[i]);
+        }
+    }
+
+    void ParameterRecorder::recordStruct(slang::SpecializationArg const& specializationArg)
+    {
+        recordEnumValue(specializationArg.kind);
+        recordAddress(specializationArg.type);
+    }
+
+    void ParameterRecorder::recordPointer(const void* value, bool omitData, size_t size)
+    {
+        recordAddress(value);
+        if (omitData)
+        {
+            recordUint64(0llu);
+            return;
+        }
+
+        recordUint64(size);
+        if (size)
+        {
+            m_stream->write(value, size);
+        }
+    }
+
+    void ParameterRecorder::recordPointer(ISlangBlob* blob)
+    {
+        recordAddress(static_cast<const void*>(blob));
+
+        if (blob)
+        {
+            size_t size = blob->getBufferSize();
+            const void* buffer = blob->getBufferPointer();
+            recordPointer(buffer, false, size);
+        }
+    }
+
+    // first 4-bytes is the length of the string
+    void ParameterRecorder::recordString(const char* value)
+    {
+        if (value == nullptr)
+        {
+            recordUint32(0);
+        }
+        else
+        {
+            uint32_t size = (uint32_t)strlen(value);
+            recordUint32(size);
+            m_stream->write(value, size);
+        }
+    }
+}