Support in memory frame capture replay

scripts/code_generation_hashes/GL_EGL_entry_points.json

@@ -6,7 +6,7 @@
   "scripts/entry_point_packed_gl_enums.json":
     "7a8fdb26e6c70a091039789d51d6c30a",
   "scripts/generate_entry_points.py":
-    "0e171ae96ddf02733e37acc8942e3e0d",
+    "00dc8410ad87e122314ac58579445188",
   "scripts/gl.xml":
     "b470cb06b06cbbe7adb2c8129ec85708",
   "scripts/gl_angle_ext.xml":
@@ -87,10 +87,12 @@
     "97b5fe98b95b4ae36c68f723e64f993a",
   "src/libANGLE/entry_points_enum_autogen.h":
     "f028ca107fe86e586e676a32863d2167",
+  "src/libANGLE/frame_capture_replay_autogen.cpp":
+    "0775906ffd94eb20b8012a3e22c13dad",
   "src/libANGLE/frame_capture_utils_autogen.cpp":
     "1b9e6440e9c7a67cfeb37aba06e7f9a8",
   "src/libANGLE/frame_capture_utils_autogen.h":
-    "1dc4ceba91b09953ec935d6e683d9a1c",
+    "d847a610224faa286787dae4fe81dc83",
   "src/libANGLE/validationES1_autogen.h":
     "8d3131d2bf2e6f521f46b44e64a6bff9",
   "src/libANGLE/validationES2_autogen.h":

scripts/generate_entry_points.py

@@ -354,6 +354,49 @@ template_parameter_capture_pointer = """
 
 template_parameter_capture_pointer_func = """void {name}({params});"""
 
+template_capture_replay_source = """// GENERATED FILE - DO NOT EDIT.
+// Generated by {script_name} using data from {data_source_name}.
+//
+// Copyright {year} The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// frame_capture_replay_autogen.cpp:
+//   Util function to dispatch captured GL calls through Context and replay them.
+
+#include "angle_gl.h"
+
+#include "common/debug.h"
+#include "common/debug.h"
+#include "libANGLE/Context.h"
+#include "libANGLE/Context.inl.h"
+#include "libANGLE/FrameCapture.h"
+
+using namespace gl;
+
+namespace angle
+{{
+
+void FrameCapture::ReplayCall(gl::Context *context,
+                              ReplayContext *replayContext,
+                              const CallCapture &call)
+{{
+    const ParamBuffer &params = call.params;
+    switch (call.entryPoint)
+    {{
+        {call_replay_cases}
+        default:
+            UNREACHABLE();
+    }}
+}}
+
+}}  // namespace angle
+
+"""
+
+template_capture_replay_call_case = """case gl::EntryPoint::{entry_point}:
+    context->{context_call}({param_value_access});break;"""
+
 static_cast_to_dict = {
     "GLintptr": "unsigned long long",
     "GLsizeiptr": "unsigned long long",
@@ -485,6 +528,28 @@ union ParamValue
 }};
 
 template <ParamType PType, typename T>
+T GetParamVal(const ParamValue &value);
+
+{get_param_val_specializations}
+
+
+template <ParamType PType, typename T>
+T GetParamVal(const ParamValue &value)
+{{
+    UNREACHABLE();
+    return T();
+}}
+
+template <typename T>
+T AccessParamValue(ParamType paramType, const ParamValue &value)
+{{
+    switch (paramType)
+    {{
+{access_param_value_cases}
+    }}
+}}
+
+template <ParamType PType, typename T>
 void SetParamVal(T valueIn, ParamValue *valueOut);
 
 {set_param_val_specializations}
@@ -551,6 +616,15 @@ const char *ParamTypeToString(ParamType paramType)
 }}  // namespace angle
 """
 
+template_get_param_val_specialization = """template <>
+inline {type} GetParamVal<ParamType::T{enum}, {type}>(const ParamValue &value)
+{{
+    return value.{union_name};
+}}"""
+
+template_access_param_value_case = """        case ParamType::T{enum}:
+    return GetParamVal<ParamType::T{enum}, T>(value);"""
+
 template_set_param_val_specialization = """template <>
 inline void SetParamVal<ParamType::T{enum}>({type} valueIn, ParamValue *valueOut)
 {{
@@ -1213,6 +1287,17 @@ def format_param_type_union_type(param_type):
     return "%s %s;" % (get_param_type_type(param_type), get_param_type_union_name(param_type))
 
 
+def format_get_param_val_specialization(param_type):
+    return template_get_param_val_specialization.format(
+        enum=param_type,
+        type=get_param_type_type(param_type),
+        union_name=get_param_type_union_name(param_type))
+
+
+def format_access_param_value_case(param_type):
+    return template_access_param_value_case.format(enum=param_type)
+
+
 def format_set_param_val_specialization(param_type):
     return template_set_param_val_specialization.format(
         enum=param_type,
@@ -1233,6 +1318,10 @@ def write_capture_helper_header(all_param_types):
 
     param_types = "\n    ".join(["T%s," % t for t in all_param_types])
     param_union_values = "\n    ".join([format_param_type_union_type(t) for t in all_param_types])
+    get_param_val_specializations = "\n\n".join(
+        [format_get_param_val_specialization(t) for t in all_param_types])
+    access_param_value_cases = "\n".join(
+        [format_access_param_value_case(t) for t in all_param_types])
     set_param_val_specializations = "\n\n".join(
         [format_set_param_val_specialization(t) for t in all_param_types])
     init_param_value_cases = "\n".join([format_init_param_value_case(t) for t in all_param_types])
@@ -1243,6 +1332,8 @@ def write_capture_helper_header(all_param_types):
         year=date.today().year,
         param_types=param_types,
         param_union_values=param_union_values,
+        get_param_val_specializations=get_param_val_specializations,
+        access_param_value_cases=access_param_value_cases,
         set_param_val_specializations=set_param_val_specializations,
         init_param_value_cases=init_param_value_cases)
 
@@ -1279,6 +1370,89 @@ def write_capture_helper_source(all_param_types):
         out.close()
 
 
+def get_command_params_text(command_node, cmd_name):
+    param_text_list = list()
+    for param_node in command_node.findall('param'):
+        param_text_list.append("".join(param_node.itertext()))
+    return param_text_list
+
+
+def is_get_pointer_command(command_name):
+    return command_name.endswith('Pointerv') and command_name.startswith('glGet')
+
+
+def format_capture_replay_param_access(command_name, param_text_list, cmd_packed_gl_enums):
+    param_access_strs = list()
+    cmd_packed_enums = get_packed_enums(cmd_packed_gl_enums, command_name)
+    for i, param_text in enumerate(param_text_list):
+        param_type = just_the_type_packed(param_text, cmd_packed_enums)
+        param_name = just_the_name_packed(param_text, cmd_packed_enums)
+
+        pointer_count = param_type.count('*')
+        is_const = 'const' in param_type
+        if pointer_count == 0:
+            param_template = 'params.getParam("{name}", ParamType::T{enum_type}, {index}).value.{enum_type}Val'
+        elif pointer_count == 1 and is_const:
+            param_template = 'replayContext->getAsConstPointer<{type}>(params.getParam("{name}", ParamType::T{enum_type}, {index}))'
+        elif pointer_count == 2 and is_const:
+            param_template = 'replayContext->getAsPointerConstPointer<{type}>(params.getParam("{name}", ParamType::T{enum_type}, {index}))'
+        elif pointer_count == 1 or (pointer_count == 2 and is_get_pointer_command(command_name)):
+            param_template = 'replayContext->getReadBufferPointer<{type}>(params.getParam("{name}", ParamType::T{enum_type}, {index}))'
+        else:
+            assert False, "Not supported param type %s" % param_type
+
+        param_access_strs.append(
+            param_template.format(
+                index=i,
+                name=param_name,
+                type=param_type,
+                enum_type=get_capture_param_type_name(param_type)))
+    return ",".join(param_access_strs)
+
+
+def format_capture_replay_call_case(command_to_param_types_mapping, cmd_packed_gl_enums):
+    call_str_list = list()
+    for command_name, cmd_param_texts in sorted(command_to_param_types_mapping.items()):
+        entry_point_name = command_name[2:]  # strip the 'gl' prefix
+
+        call_str_list.append(
+            template_capture_replay_call_case.format(
+                entry_point=entry_point_name,
+                param_value_access=format_capture_replay_param_access(
+                    command_name, cmd_param_texts, cmd_packed_gl_enums),
+                context_call=entry_point_name[0].lower() + entry_point_name[1:],
+            ))
+
+    return '\n'.join(call_str_list)
+
+
+def write_capture_replay_source(all_commands_nodes, gles_command_names, cmd_packed_gl_enums):
+    all_commands_names = set(gles_command_names)
+
+    command_to_param_types_mapping = dict()
+    for command_node in all_commands_nodes:
+        command_name = command_node.find('proto').find('name').text
+        if command_name not in all_commands_names:
+            continue
+
+        command_to_param_types_mapping[command_name] = get_command_params_text(
+            command_node, command_name)
+
+    call_replay_cases = format_capture_replay_call_case(command_to_param_types_mapping,
+                                                        cmd_packed_gl_enums)
+
+    source_content = template_capture_replay_source.format(
+        script_name=os.path.basename(sys.argv[0]),
+        data_source_name="gl.xml and gl_angle_ext.xml",
+        year=date.today().year,
+        call_replay_cases=call_replay_cases,
+    )
+    source_file_path = registry_xml.script_relative(
+        "../src/libANGLE/frame_capture_replay_autogen.cpp")
+    with open(source_file_path, 'w') as f:
+        f.write(source_content)
+
+
 def write_windows_def_file(data_source_name, lib, libexport, folder, exports):
 
     content = template_windows_def_file.format(
@@ -1379,6 +1553,7 @@ def main():
             '../src/libANGLE/capture_gles_3_1_autogen.h',
             '../src/libANGLE/capture_gles_ext_autogen.cpp',
             '../src/libANGLE/capture_gles_ext_autogen.h',
+            '../src/libANGLE/frame_capture_replay_autogen.cpp',
             '../src/libANGLE/frame_capture_utils_autogen.cpp',
             '../src/libANGLE/frame_capture_utils_autogen.h',
             '../src/libANGLE/entry_points_enum_autogen.cpp',
@@ -1894,6 +2069,7 @@ def main():
     all_gles_param_types = sorted(all_gles_param_types)
     write_capture_helper_header(all_gles_param_types)
     write_capture_helper_source(all_gles_param_types)
+    write_capture_replay_source(xml.all_commands, all_commands_no_suffix, cmd_packed_gl_enums)
 
 
 if __name__ == '__main__':

src/libANGLE/FrameCapture.cpp

@@ -61,6 +61,7 @@ ParamCapture::~ParamCapture() {}
 FrameCapture::FrameCapture() {}
 FrameCapture::~FrameCapture() {}
 void FrameCapture::onEndFrame() {}
+void FrameCapture::replay(gl::Context *context) {}
 #else
 namespace
 {
@@ -219,6 +220,18 @@ const char *CallCapture::name() const
     return gl::GetEntryPointName(entryPoint);
 }
 
+ReplayContext::ReplayContext(size_t readBufferSizebytes,
+                             const gl::AttribArray<size_t> &clientArraysSizebytes)
+{
+    mReadBuffer.resize(readBufferSizebytes);
+
+    for (uint32_t i = 0; i < clientArraysSizebytes.size(); i++)
+    {
+        mClientArraysBuffer[i].resize(clientArraysSizebytes[i]);
+    }
+}
+ReplayContext::~ReplayContext() {}
+
 FrameCapture::FrameCapture() : mFrameIndex(0), mReadBufferSize(0)
 {
     reset();
@@ -290,7 +303,8 @@ void FrameCapture::maybeCaptureClientData(const gl::Context *context, const Call
                     indexRange = gl::ComputeIndexRange(drawElementsType, indices, count, restart);
                 }
 
-                captureClientArraySnapshot(context, indexRange.end, 1);
+                // index starts from 0
+                captureClientArraySnapshot(context, indexRange.end + 1, 1);
             }
             break;
         }
@@ -729,6 +743,41 @@ bool FrameCapture::enabled() const
     return mFrameIndex < 100;
 }
 
+void FrameCapture::replay(gl::Context *context)
+{
+    ReplayContext replayContext(mReadBufferSize, mClientArraySizes);
+    for (const CallCapture &call : mCalls)
+    {
+        INFO() << "frame index: " << mFrameIndex << " " << call.name();
+
+        if (call.entryPoint == gl::EntryPoint::Invalid)
+        {
+            if (call.customFunctionName == "UpdateClientArrayPointer")
+            {
+                GLint arrayIndex =
+                    call.params.getParam("arrayIndex", ParamType::TGLint, 0).value.GLintVal;
+                ASSERT(arrayIndex < gl::MAX_VERTEX_ATTRIBS);
+
+                const ParamCapture &pointerParam =
+                    call.params.getParam("pointer", ParamType::TvoidConstPointer, 1);
+                ASSERT(pointerParam.data.size() == 1);
+                const void *pointer = pointerParam.data[0].data();
+
+                size_t size = static_cast<size_t>(
+                    call.params.getParam("size", ParamType::TGLuint64, 2).value.GLuint64Val);
+
+                std::vector<uint8_t> &curClientArrayBuffer =
+                    replayContext.getClientArraysBuffer()[arrayIndex];
+                ASSERT(curClientArrayBuffer.size() >= size);
+                memcpy(curClientArrayBuffer.data(), pointer, size);
+            }
+            continue;
+        }
+
+        ReplayCall(context, &replayContext, call);
+    }
+}
+
 void FrameCapture::reset()
 {
     mCalls.clear();
@@ -753,7 +802,8 @@ void CaptureMemory(const void *source, size_t size, ParamCapture *paramCapture)
 
 void CaptureString(const GLchar *str, ParamCapture *paramCapture)
 {
-    CaptureMemory(str, strlen(str), paramCapture);
+    // include the '\0' suffix
+    CaptureMemory(str, strlen(str) + 1, paramCapture);
 }
 
 template <>

src/libANGLE/FrameCapture.h

@@ -95,6 +95,60 @@ struct CallCapture
     ParamBuffer params;
 };
 
+class ReplayContext
+{
+  public:
+    ReplayContext(size_t readBufferSizebytes, const gl::AttribArray<size_t> &clientArraysSizebytes);
+    ~ReplayContext();
+
+    template <typename T>
+    T getReadBufferPointer(const ParamCapture &param)
+    {
+        ASSERT(param.readBufferSizeBytes > 0);
+        ASSERT(mReadBuffer.size() >= param.readBufferSizeBytes);
+        return reinterpret_cast<T>(mReadBuffer.data());
+    }
+    template <typename T>
+    T getAsConstPointer(const ParamCapture &param)
+    {
+        if (param.arrayClientPointerIndex != -1)
+        {
+            return reinterpret_cast<T>(mClientArraysBuffer[param.arrayClientPointerIndex].data());
+        }
+
+        if (!param.data.empty())
+        {
+            ASSERT(param.data.size() == 1);
+            return reinterpret_cast<T>(param.data[0].data());
+        }
+
+        return nullptr;
+    }
+
+    template <typename T>
+    T getAsPointerConstPointer(const ParamCapture &param)
+    {
+        static_assert(sizeof(typename std::remove_pointer<T>::type) == sizeof(uint8_t *),
+                      "pointer size not match!");
+
+        ASSERT(!param.data.empty());
+        mPointersBuffer.clear();
+        mPointersBuffer.reserve(param.data.size());
+        for (const std::vector<uint8_t> &data : param.data)
+        {
+            mPointersBuffer.emplace_back(data.data());
+        }
+        return reinterpret_cast<T>(mPointersBuffer.data());
+    }
+
+    gl::AttribArray<std::vector<uint8_t>> &getClientArraysBuffer() { return mClientArraysBuffer; }
+
+  private:
+    std::vector<uint8_t> mReadBuffer;
+    std::vector<const uint8_t *> mPointersBuffer;
+    gl::AttribArray<std::vector<uint8_t>> mClientArraysBuffer;
+};
+
 class FrameCapture final : angle::NonCopyable
 {
   public:
@@ -104,6 +158,7 @@ class FrameCapture final : angle::NonCopyable
     void captureCall(const gl::Context *context, CallCapture &&call);
     void onEndFrame();
     bool enabled() const;
+    void replay(gl::Context *context);
 
   private:
     // <CallName, ParamName>
@@ -143,6 +198,10 @@ class FrameCapture final : angle::NonCopyable
     gl::AttribArray<size_t> mClientArraySizes;
     std::map<Counter, int> mDataCounters;
     size_t mReadBufferSize;
+
+    static void ReplayCall(gl::Context *context,
+                           ReplayContext *replayContext,
+                           const CallCapture &call);
 };
 
 template <typename CaptureFuncT, typename... ArgsT>

src/libANGLE/capture_gles_2_0_params.cpp

@@ -643,8 +643,10 @@ void CaptureShaderSource_string(const Context *context,
 {
     for (GLsizei index = 0; index < count; ++index)
     {
-        size_t len = length ? length[index] : strlen(string[index]);
+        // includes the '\0' suffix
+        size_t len = (length ? length[index] : strlen(string[index])) + 1;
         CaptureMemory(string[index], len, paramCapture);
+        paramCapture->data[paramCapture->data.size() - 1][len] = '\0';
     }
 }
 

src/libANGLE/frame_capture_utils_autogen.h

@@ -214,6 +214,836 @@ union ParamValue
 };
 
 template <ParamType PType, typename T>
+T GetParamVal(const ParamValue &value);
+
+template <>
+inline gl::AlphaTestFunc GetParamVal<ParamType::TAlphaTestFunc, gl::AlphaTestFunc>(
+    const ParamValue &value)
+{
+    return value.AlphaTestFuncVal;
+}
+
+template <>
+inline gl::BufferBinding GetParamVal<ParamType::TBufferBinding, gl::BufferBinding>(
+    const ParamValue &value)
+{
+    return value.BufferBindingVal;
+}
+
+template <>
+inline gl::BufferID GetParamVal<ParamType::TBufferID, gl::BufferID>(const ParamValue &value)
+{
+    return value.BufferIDVal;
+}
+
+template <>
+inline const gl::BufferID *GetParamVal<ParamType::TBufferIDConstPointer, const gl::BufferID *>(
+    const ParamValue &value)
+{
+    return value.BufferIDConstPointerVal;
+}
+
+template <>
+inline gl::BufferID *GetParamVal<ParamType::TBufferIDPointer, gl::BufferID *>(
+    const ParamValue &value)
+{
+    return value.BufferIDPointerVal;
+}
+
+template <>
+inline gl::BufferUsage GetParamVal<ParamType::TBufferUsage, gl::BufferUsage>(
+    const ParamValue &value)
+{
+    return value.BufferUsageVal;
+}
+
+template <>
+inline gl::ClientVertexArrayType
+GetParamVal<ParamType::TClientVertexArrayType, gl::ClientVertexArrayType>(const ParamValue &value)
+{
+    return value.ClientVertexArrayTypeVal;
+}
+
+template <>
+inline gl::CullFaceMode GetParamVal<ParamType::TCullFaceMode, gl::CullFaceMode>(
+    const ParamValue &value)
+{
+    return value.CullFaceModeVal;
+}
+
+template <>
+inline gl::DrawElementsType GetParamVal<ParamType::TDrawElementsType, gl::DrawElementsType>(
+    const ParamValue &value)
+{
+    return value.DrawElementsTypeVal;
+}
+
+template <>
+inline gl::FenceNVID GetParamVal<ParamType::TFenceNVID, gl::FenceNVID>(const ParamValue &value)
+{
+    return value.FenceNVIDVal;
+}
+
+template <>
+inline const gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDConstPointer, const gl::FenceNVID *>(
+    const ParamValue &value)
+{
+    return value.FenceNVIDConstPointerVal;
+}
+
+template <>
+inline gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDPointer, gl::FenceNVID *>(
+    const ParamValue &value)
+{
+    return value.FenceNVIDPointerVal;
+}
+
+template <>
+inline GLDEBUGPROC GetParamVal<ParamType::TGLDEBUGPROC, GLDEBUGPROC>(const ParamValue &value)
+{
+    return value.GLDEBUGPROCVal;
+}
+
+template <>
+inline GLDEBUGPROCKHR GetParamVal<ParamType::TGLDEBUGPROCKHR, GLDEBUGPROCKHR>(
+    const ParamValue &value)
+{
+    return value.GLDEBUGPROCKHRVal;
+}
+
+template <>
+inline GLbitfield GetParamVal<ParamType::TGLbitfield, GLbitfield>(const ParamValue &value)
+{
+    return value.GLbitfieldVal;
+}
+
+template <>
+inline GLboolean GetParamVal<ParamType::TGLboolean, GLboolean>(const ParamValue &value)
+{
+    return value.GLbooleanVal;
+}
+
+template <>
+inline const GLboolean *GetParamVal<ParamType::TGLbooleanConstPointer, const GLboolean *>(
+    const ParamValue &value)
+{
+    return value.GLbooleanConstPointerVal;
+}
+
+template <>
+inline GLboolean *GetParamVal<ParamType::TGLbooleanPointer, GLboolean *>(const ParamValue &value)
+{
+    return value.GLbooleanPointerVal;
+}
+
+template <>
+inline GLbyte GetParamVal<ParamType::TGLbyte, GLbyte>(const ParamValue &value)
+{
+    return value.GLbyteVal;
+}
+
+template <>
+inline const GLbyte *GetParamVal<ParamType::TGLbyteConstPointer, const GLbyte *>(
+    const ParamValue &value)
+{
+    return value.GLbyteConstPointerVal;
+}
+
+template <>
+inline const GLchar *GetParamVal<ParamType::TGLcharConstPointer, const GLchar *>(
+    const ParamValue &value)
+{
+    return value.GLcharConstPointerVal;
+}
+
+template <>
+inline const GLchar *const *
+GetParamVal<ParamType::TGLcharConstPointerPointer, const GLchar *const *>(const ParamValue &value)
+{
+    return value.GLcharConstPointerPointerVal;
+}
+
+template <>
+inline GLchar *GetParamVal<ParamType::TGLcharPointer, GLchar *>(const ParamValue &value)
+{
+    return value.GLcharPointerVal;
+}
+
+template <>
+inline GLclampx GetParamVal<ParamType::TGLclampx, GLclampx>(const ParamValue &value)
+{
+    return value.GLclampxVal;
+}
+
+template <>
+inline GLdouble GetParamVal<ParamType::TGLdouble, GLdouble>(const ParamValue &value)
+{
+    return value.GLdoubleVal;
+}
+
+template <>
+inline const GLdouble *GetParamVal<ParamType::TGLdoubleConstPointer, const GLdouble *>(
+    const ParamValue &value)
+{
+    return value.GLdoubleConstPointerVal;
+}
+
+template <>
+inline GLdouble *GetParamVal<ParamType::TGLdoublePointer, GLdouble *>(const ParamValue &value)
+{
+    return value.GLdoublePointerVal;
+}
+
+template <>
+inline GLeglImageOES GetParamVal<ParamType::TGLeglImageOES, GLeglImageOES>(const ParamValue &value)
+{
+    return value.GLeglImageOESVal;
+}
+
+template <>
+inline GLenum GetParamVal<ParamType::TGLenum, GLenum>(const ParamValue &value)
+{
+    return value.GLenumVal;
+}
+
+template <>
+inline const GLenum *GetParamVal<ParamType::TGLenumConstPointer, const GLenum *>(
+    const ParamValue &value)
+{
+    return value.GLenumConstPointerVal;
+}
+
+template <>
+inline GLenum *GetParamVal<ParamType::TGLenumPointer, GLenum *>(const ParamValue &value)
+{
+    return value.GLenumPointerVal;
+}
+
+template <>
+inline GLfixed GetParamVal<ParamType::TGLfixed, GLfixed>(const ParamValue &value)
+{
+    return value.GLfixedVal;
+}
+
+template <>
+inline const GLfixed *GetParamVal<ParamType::TGLfixedConstPointer, const GLfixed *>(
+    const ParamValue &value)
+{
+    return value.GLfixedConstPointerVal;
+}
+
+template <>
+inline GLfixed *GetParamVal<ParamType::TGLfixedPointer, GLfixed *>(const ParamValue &value)
+{
+    return value.GLfixedPointerVal;
+}
+
+template <>
+inline GLfloat GetParamVal<ParamType::TGLfloat, GLfloat>(const ParamValue &value)
+{
+    return value.GLfloatVal;
+}
+
+template <>
+inline const GLfloat *GetParamVal<ParamType::TGLfloatConstPointer, const GLfloat *>(
+    const ParamValue &value)
+{
+    return value.GLfloatConstPointerVal;
+}
+
+template <>
+inline GLfloat *GetParamVal<ParamType::TGLfloatPointer, GLfloat *>(const ParamValue &value)
+{
+    return value.GLfloatPointerVal;
+}
+
+template <>
+inline GLint GetParamVal<ParamType::TGLint, GLint>(const ParamValue &value)
+{
+    return value.GLintVal;
+}
+
+template <>
+inline GLint64 *GetParamVal<ParamType::TGLint64Pointer, GLint64 *>(const ParamValue &value)
+{
+    return value.GLint64PointerVal;
+}
+
+template <>
+inline const GLint *GetParamVal<ParamType::TGLintConstPointer, const GLint *>(
+    const ParamValue &value)
+{
+    return value.GLintConstPointerVal;
+}
+
+template <>
+inline GLint *GetParamVal<ParamType::TGLintPointer, GLint *>(const ParamValue &value)
+{
+    return value.GLintPointerVal;
+}
+
+template <>
+inline GLintptr GetParamVal<ParamType::TGLintptr, GLintptr>(const ParamValue &value)
+{
+    return value.GLintptrVal;
+}
+
+template <>
+inline const GLintptr *GetParamVal<ParamType::TGLintptrConstPointer, const GLintptr *>(
+    const ParamValue &value)
+{
+    return value.GLintptrConstPointerVal;
+}
+
+template <>
+inline GLshort GetParamVal<ParamType::TGLshort, GLshort>(const ParamValue &value)
+{
+    return value.GLshortVal;
+}
+
+template <>
+inline const GLshort *GetParamVal<ParamType::TGLshortConstPointer, const GLshort *>(
+    const ParamValue &value)
+{
+    return value.GLshortConstPointerVal;
+}
+
+template <>
+inline GLsizei GetParamVal<ParamType::TGLsizei, GLsizei>(const ParamValue &value)
+{
+    return value.GLsizeiVal;
+}
+
+template <>
+inline const GLsizei *GetParamVal<ParamType::TGLsizeiConstPointer, const GLsizei *>(
+    const ParamValue &value)
+{
+    return value.GLsizeiConstPointerVal;
+}
+
+template <>
+inline GLsizei *GetParamVal<ParamType::TGLsizeiPointer, GLsizei *>(const ParamValue &value)
+{
+    return value.GLsizeiPointerVal;
+}
+
+template <>
+inline GLsizeiptr GetParamVal<ParamType::TGLsizeiptr, GLsizeiptr>(const ParamValue &value)
+{
+    return value.GLsizeiptrVal;
+}
+
+template <>
+inline const GLsizeiptr *GetParamVal<ParamType::TGLsizeiptrConstPointer, const GLsizeiptr *>(
+    const ParamValue &value)
+{
+    return value.GLsizeiptrConstPointerVal;
+}
+
+template <>
+inline GLsync GetParamVal<ParamType::TGLsync, GLsync>(const ParamValue &value)
+{
+    return value.GLsyncVal;
+}
+
+template <>
+inline GLubyte GetParamVal<ParamType::TGLubyte, GLubyte>(const ParamValue &value)
+{
+    return value.GLubyteVal;
+}
+
+template <>
+inline const GLubyte *GetParamVal<ParamType::TGLubyteConstPointer, const GLubyte *>(
+    const ParamValue &value)
+{
+    return value.GLubyteConstPointerVal;
+}
+
+template <>
+inline GLubyte *GetParamVal<ParamType::TGLubytePointer, GLubyte *>(const ParamValue &value)
+{
+    return value.GLubytePointerVal;
+}
+
+template <>
+inline GLuint GetParamVal<ParamType::TGLuint, GLuint>(const ParamValue &value)
+{
+    return value.GLuintVal;
+}
+
+template <>
+inline GLuint64 GetParamVal<ParamType::TGLuint64, GLuint64>(const ParamValue &value)
+{
+    return value.GLuint64Val;
+}
+
+template <>
+inline const GLuint64 *GetParamVal<ParamType::TGLuint64ConstPointer, const GLuint64 *>(
+    const ParamValue &value)
+{
+    return value.GLuint64ConstPointerVal;
+}
+
+template <>
+inline GLuint64 *GetParamVal<ParamType::TGLuint64Pointer, GLuint64 *>(const ParamValue &value)
+{
+    return value.GLuint64PointerVal;
+}
+
+template <>
+inline const GLuint *GetParamVal<ParamType::TGLuintConstPointer, const GLuint *>(
+    const ParamValue &value)
+{
+    return value.GLuintConstPointerVal;
+}
+
+template <>
+inline GLuint *GetParamVal<ParamType::TGLuintPointer, GLuint *>(const ParamValue &value)
+{
+    return value.GLuintPointerVal;
+}
+
+template <>
+inline GLushort GetParamVal<ParamType::TGLushort, GLushort>(const ParamValue &value)
+{
+    return value.GLushortVal;
+}
+
+template <>
+inline const GLushort *GetParamVal<ParamType::TGLushortConstPointer, const GLushort *>(
+    const ParamValue &value)
+{
+    return value.GLushortConstPointerVal;
+}
+
+template <>
+inline GLushort *GetParamVal<ParamType::TGLushortPointer, GLushort *>(const ParamValue &value)
+{
+    return value.GLushortPointerVal;
+}
+
+template <>
+inline const GLvoid *GetParamVal<ParamType::TGLvoidConstPointer, const GLvoid *>(
+    const ParamValue &value)
+{
+    return value.GLvoidConstPointerVal;
+}
+
+template <>
+inline const GLvoid *const *
+GetParamVal<ParamType::TGLvoidConstPointerPointer, const GLvoid *const *>(const ParamValue &value)
+{
+    return value.GLvoidConstPointerPointerVal;
+}
+
+template <>
+inline gl::GraphicsResetStatus
+GetParamVal<ParamType::TGraphicsResetStatus, gl::GraphicsResetStatus>(const ParamValue &value)
+{
+    return value.GraphicsResetStatusVal;
+}
+
+template <>
+inline gl::HandleType GetParamVal<ParamType::THandleType, gl::HandleType>(const ParamValue &value)
+{
+    return value.HandleTypeVal;
+}
+
+template <>
+inline gl::LightParameter GetParamVal<ParamType::TLightParameter, gl::LightParameter>(
+    const ParamValue &value)
+{
+    return value.LightParameterVal;
+}
+
+template <>
+inline gl::LogicalOperation GetParamVal<ParamType::TLogicalOperation, gl::LogicalOperation>(
+    const ParamValue &value)
+{
+    return value.LogicalOperationVal;
+}
+
+template <>
+inline gl::MaterialParameter GetParamVal<ParamType::TMaterialParameter, gl::MaterialParameter>(
+    const ParamValue &value)
+{
+    return value.MaterialParameterVal;
+}
+
+template <>
+inline gl::MatrixType GetParamVal<ParamType::TMatrixType, gl::MatrixType>(const ParamValue &value)
+{
+    return value.MatrixTypeVal;
+}
+
+template <>
+inline gl::PointParameter GetParamVal<ParamType::TPointParameter, gl::PointParameter>(
+    const ParamValue &value)
+{
+    return value.PointParameterVal;
+}
+
+template <>
+inline gl::PrimitiveMode GetParamVal<ParamType::TPrimitiveMode, gl::PrimitiveMode>(
+    const ParamValue &value)
+{
+    return value.PrimitiveModeVal;
+}
+
+template <>
+inline gl::ProvokingVertexConvention
+GetParamVal<ParamType::TProvokingVertexConvention, gl::ProvokingVertexConvention>(
+    const ParamValue &value)
+{
+    return value.ProvokingVertexConventionVal;
+}
+
+template <>
+inline gl::QueryType GetParamVal<ParamType::TQueryType, gl::QueryType>(const ParamValue &value)
+{
+    return value.QueryTypeVal;
+}
+
+template <>
+inline gl::RenderbufferID GetParamVal<ParamType::TRenderbufferID, gl::RenderbufferID>(
+    const ParamValue &value)
+{
+    return value.RenderbufferIDVal;
+}
+
+template <>
+inline const gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDConstPointer,
+                                             const gl::RenderbufferID *>(const ParamValue &value)
+{
+    return value.RenderbufferIDConstPointerVal;
+}
+
+template <>
+inline gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDPointer, gl::RenderbufferID *>(
+    const ParamValue &value)
+{
+    return value.RenderbufferIDPointerVal;
+}
+
+template <>
+inline gl::SamplerID GetParamVal<ParamType::TSamplerID, gl::SamplerID>(const ParamValue &value)
+{
+    return value.SamplerIDVal;
+}
+
+template <>
+inline const gl::SamplerID *GetParamVal<ParamType::TSamplerIDConstPointer, const gl::SamplerID *>(
+    const ParamValue &value)
+{
+    return value.SamplerIDConstPointerVal;
+}
+
+template <>
+inline gl::SamplerID *GetParamVal<ParamType::TSamplerIDPointer, gl::SamplerID *>(
+    const ParamValue &value)
+{
+    return value.SamplerIDPointerVal;
+}
+
+template <>
+inline gl::ShaderType GetParamVal<ParamType::TShaderType, gl::ShaderType>(const ParamValue &value)
+{
+    return value.ShaderTypeVal;
+}
+
+template <>
+inline gl::ShadingModel GetParamVal<ParamType::TShadingModel, gl::ShadingModel>(
+    const ParamValue &value)
+{
+    return value.ShadingModelVal;
+}
+
+template <>
+inline gl::TextureEnvParameter
+GetParamVal<ParamType::TTextureEnvParameter, gl::TextureEnvParameter>(const ParamValue &value)
+{
+    return value.TextureEnvParameterVal;
+}
+
+template <>
+inline gl::TextureEnvTarget GetParamVal<ParamType::TTextureEnvTarget, gl::TextureEnvTarget>(
+    const ParamValue &value)
+{
+    return value.TextureEnvTargetVal;
+}
+
+template <>
+inline gl::TextureID GetParamVal<ParamType::TTextureID, gl::TextureID>(const ParamValue &value)
+{
+    return value.TextureIDVal;
+}
+
+template <>
+inline const gl::TextureID *GetParamVal<ParamType::TTextureIDConstPointer, const gl::TextureID *>(
+    const ParamValue &value)
+{
+    return value.TextureIDConstPointerVal;
+}
+
+template <>
+inline gl::TextureID *GetParamVal<ParamType::TTextureIDPointer, gl::TextureID *>(
+    const ParamValue &value)
+{
+    return value.TextureIDPointerVal;
+}
+
+template <>
+inline gl::TextureTarget GetParamVal<ParamType::TTextureTarget, gl::TextureTarget>(
+    const ParamValue &value)
+{
+    return value.TextureTargetVal;
+}
+
+template <>
+inline gl::TextureType GetParamVal<ParamType::TTextureType, gl::TextureType>(
+    const ParamValue &value)
+{
+    return value.TextureTypeVal;
+}
+
+template <>
+inline gl::VertexAttribType GetParamVal<ParamType::TVertexAttribType, gl::VertexAttribType>(
+    const ParamValue &value)
+{
+    return value.VertexAttribTypeVal;
+}
+
+template <>
+inline const void *GetParamVal<ParamType::TvoidConstPointer, const void *>(const ParamValue &value)
+{
+    return value.voidConstPointerVal;
+}
+
+template <>
+inline const void *const *GetParamVal<ParamType::TvoidConstPointerPointer, const void *const *>(
+    const ParamValue &value)
+{
+    return value.voidConstPointerPointerVal;
+}
+
+template <>
+inline void *GetParamVal<ParamType::TvoidPointer, void *>(const ParamValue &value)
+{
+    return value.voidPointerVal;
+}
+
+template <>
+inline void **GetParamVal<ParamType::TvoidPointerPointer, void **>(const ParamValue &value)
+{
+    return value.voidPointerPointerVal;
+}
+
+template <ParamType PType, typename T>
+T GetParamVal(const ParamValue &value)
+{
+    UNREACHABLE();
+    return T();
+}
+
+template <typename T>
+T AccessParamValue(ParamType paramType, const ParamValue &value)
+{
+    switch (paramType)
+    {
+        case ParamType::TAlphaTestFunc:
+            return GetParamVal<ParamType::TAlphaTestFunc, T>(value);
+        case ParamType::TBufferBinding:
+            return GetParamVal<ParamType::TBufferBinding, T>(value);
+        case ParamType::TBufferID:
+            return GetParamVal<ParamType::TBufferID, T>(value);
+        case ParamType::TBufferIDConstPointer:
+            return GetParamVal<ParamType::TBufferIDConstPointer, T>(value);
+        case ParamType::TBufferIDPointer:
+            return GetParamVal<ParamType::TBufferIDPointer, T>(value);
+        case ParamType::TBufferUsage:
+            return GetParamVal<ParamType::TBufferUsage, T>(value);
+        case ParamType::TClientVertexArrayType:
+            return GetParamVal<ParamType::TClientVertexArrayType, T>(value);
+        case ParamType::TCullFaceMode:
+            return GetParamVal<ParamType::TCullFaceMode, T>(value);
+        case ParamType::TDrawElementsType:
+            return GetParamVal<ParamType::TDrawElementsType, T>(value);
+        case ParamType::TFenceNVID:
+            return GetParamVal<ParamType::TFenceNVID, T>(value);
+        case ParamType::TFenceNVIDConstPointer:
+            return GetParamVal<ParamType::TFenceNVIDConstPointer, T>(value);
+        case ParamType::TFenceNVIDPointer:
+            return GetParamVal<ParamType::TFenceNVIDPointer, T>(value);
+        case ParamType::TGLDEBUGPROC:
+            return GetParamVal<ParamType::TGLDEBUGPROC, T>(value);
+        case ParamType::TGLDEBUGPROCKHR:
+            return GetParamVal<ParamType::TGLDEBUGPROCKHR, T>(value);
+        case ParamType::TGLbitfield:
+            return GetParamVal<ParamType::TGLbitfield, T>(value);
+        case ParamType::TGLboolean:
+            return GetParamVal<ParamType::TGLboolean, T>(value);
+        case ParamType::TGLbooleanConstPointer:
+            return GetParamVal<ParamType::TGLbooleanConstPointer, T>(value);
+        case ParamType::TGLbooleanPointer:
+            return GetParamVal<ParamType::TGLbooleanPointer, T>(value);
+        case ParamType::TGLbyte:
+            return GetParamVal<ParamType::TGLbyte, T>(value);
+        case ParamType::TGLbyteConstPointer:
+            return GetParamVal<ParamType::TGLbyteConstPointer, T>(value);
+        case ParamType::TGLcharConstPointer:
+            return GetParamVal<ParamType::TGLcharConstPointer, T>(value);
+        case ParamType::TGLcharConstPointerPointer:
+            return GetParamVal<ParamType::TGLcharConstPointerPointer, T>(value);
+        case ParamType::TGLcharPointer:
+            return GetParamVal<ParamType::TGLcharPointer, T>(value);
+        case ParamType::TGLclampx:
+            return GetParamVal<ParamType::TGLclampx, T>(value);
+        case ParamType::TGLdouble:
+            return GetParamVal<ParamType::TGLdouble, T>(value);
+        case ParamType::TGLdoubleConstPointer:
+            return GetParamVal<ParamType::TGLdoubleConstPointer, T>(value);
+        case ParamType::TGLdoublePointer:
+            return GetParamVal<ParamType::TGLdoublePointer, T>(value);
+        case ParamType::TGLeglImageOES:
+            return GetParamVal<ParamType::TGLeglImageOES, T>(value);
+        case ParamType::TGLenum:
+            return GetParamVal<ParamType::TGLenum, T>(value);
+        case ParamType::TGLenumConstPointer:
+            return GetParamVal<ParamType::TGLenumConstPointer, T>(value);
+        case ParamType::TGLenumPointer:
+            return GetParamVal<ParamType::TGLenumPointer, T>(value);
+        case ParamType::TGLfixed:
+            return GetParamVal<ParamType::TGLfixed, T>(value);
+        case ParamType::TGLfixedConstPointer:
+            return GetParamVal<ParamType::TGLfixedConstPointer, T>(value);
+        case ParamType::TGLfixedPointer:
+            return GetParamVal<ParamType::TGLfixedPointer, T>(value);
+        case ParamType::TGLfloat:
+            return GetParamVal<ParamType::TGLfloat, T>(value);
+        case ParamType::TGLfloatConstPointer:
+            return GetParamVal<ParamType::TGLfloatConstPointer, T>(value);
+        case ParamType::TGLfloatPointer:
+            return GetParamVal<ParamType::TGLfloatPointer, T>(value);
+        case ParamType::TGLint:
+            return GetParamVal<ParamType::TGLint, T>(value);
+        case ParamType::TGLint64Pointer:
+            return GetParamVal<ParamType::TGLint64Pointer, T>(value);
+        case ParamType::TGLintConstPointer:
+            return GetParamVal<ParamType::TGLintConstPointer, T>(value);
+        case ParamType::TGLintPointer:
+            return GetParamVal<ParamType::TGLintPointer, T>(value);
+        case ParamType::TGLintptr:
+            return GetParamVal<ParamType::TGLintptr, T>(value);
+        case ParamType::TGLintptrConstPointer:
+            return GetParamVal<ParamType::TGLintptrConstPointer, T>(value);
+        case ParamType::TGLshort:
+            return GetParamVal<ParamType::TGLshort, T>(value);
+        case ParamType::TGLshortConstPointer:
+            return GetParamVal<ParamType::TGLshortConstPointer, T>(value);
+        case ParamType::TGLsizei:
+            return GetParamVal<ParamType::TGLsizei, T>(value);
+        case ParamType::TGLsizeiConstPointer:
+            return GetParamVal<ParamType::TGLsizeiConstPointer, T>(value);
+        case ParamType::TGLsizeiPointer:
+            return GetParamVal<ParamType::TGLsizeiPointer, T>(value);
+        case ParamType::TGLsizeiptr:
+            return GetParamVal<ParamType::TGLsizeiptr, T>(value);
+        case ParamType::TGLsizeiptrConstPointer:
+            return GetParamVal<ParamType::TGLsizeiptrConstPointer, T>(value);
+        case ParamType::TGLsync:
+            return GetParamVal<ParamType::TGLsync, T>(value);
+        case ParamType::TGLubyte:
+            return GetParamVal<ParamType::TGLubyte, T>(value);
+        case ParamType::TGLubyteConstPointer:
+            return GetParamVal<ParamType::TGLubyteConstPointer, T>(value);
+        case ParamType::TGLubytePointer:
+            return GetParamVal<ParamType::TGLubytePointer, T>(value);
+        case ParamType::TGLuint:
+            return GetParamVal<ParamType::TGLuint, T>(value);
+        case ParamType::TGLuint64:
+            return GetParamVal<ParamType::TGLuint64, T>(value);
+        case ParamType::TGLuint64ConstPointer:
+            return GetParamVal<ParamType::TGLuint64ConstPointer, T>(value);
+        case ParamType::TGLuint64Pointer:
+            return GetParamVal<ParamType::TGLuint64Pointer, T>(value);
+        case ParamType::TGLuintConstPointer:
+            return GetParamVal<ParamType::TGLuintConstPointer, T>(value);
+        case ParamType::TGLuintPointer:
+            return GetParamVal<ParamType::TGLuintPointer, T>(value);
+        case ParamType::TGLushort:
+            return GetParamVal<ParamType::TGLushort, T>(value);
+        case ParamType::TGLushortConstPointer:
+            return GetParamVal<ParamType::TGLushortConstPointer, T>(value);
+        case ParamType::TGLushortPointer:
+            return GetParamVal<ParamType::TGLushortPointer, T>(value);
+        case ParamType::TGLvoidConstPointer:
+            return GetParamVal<ParamType::TGLvoidConstPointer, T>(value);
+        case ParamType::TGLvoidConstPointerPointer:
+            return GetParamVal<ParamType::TGLvoidConstPointerPointer, T>(value);
+        case ParamType::TGraphicsResetStatus:
+            return GetParamVal<ParamType::TGraphicsResetStatus, T>(value);
+        case ParamType::THandleType:
+            return GetParamVal<ParamType::THandleType, T>(value);
+        case ParamType::TLightParameter:
+            return GetParamVal<ParamType::TLightParameter, T>(value);
+        case ParamType::TLogicalOperation:
+            return GetParamVal<ParamType::TLogicalOperation, T>(value);
+        case ParamType::TMaterialParameter:
+            return GetParamVal<ParamType::TMaterialParameter, T>(value);
+        case ParamType::TMatrixType:
+            return GetParamVal<ParamType::TMatrixType, T>(value);
+        case ParamType::TPointParameter:
+            return GetParamVal<ParamType::TPointParameter, T>(value);
+        case ParamType::TPrimitiveMode:
+            return GetParamVal<ParamType::TPrimitiveMode, T>(value);
+        case ParamType::TProvokingVertexConvention:
+            return GetParamVal<ParamType::TProvokingVertexConvention, T>(value);
+        case ParamType::TQueryType:
+            return GetParamVal<ParamType::TQueryType, T>(value);
+        case ParamType::TRenderbufferID:
+            return GetParamVal<ParamType::TRenderbufferID, T>(value);
+        case ParamType::TRenderbufferIDConstPointer:
+            return GetParamVal<ParamType::TRenderbufferIDConstPointer, T>(value);
+        case ParamType::TRenderbufferIDPointer:
+            return GetParamVal<ParamType::TRenderbufferIDPointer, T>(value);
+        case ParamType::TSamplerID:
+            return GetParamVal<ParamType::TSamplerID, T>(value);
+        case ParamType::TSamplerIDConstPointer:
+            return GetParamVal<ParamType::TSamplerIDConstPointer, T>(value);
+        case ParamType::TSamplerIDPointer:
+            return GetParamVal<ParamType::TSamplerIDPointer, T>(value);
+        case ParamType::TShaderType:
+            return GetParamVal<ParamType::TShaderType, T>(value);
+        case ParamType::TShadingModel:
+            return GetParamVal<ParamType::TShadingModel, T>(value);
+        case ParamType::TTextureEnvParameter:
+            return GetParamVal<ParamType::TTextureEnvParameter, T>(value);
+        case ParamType::TTextureEnvTarget:
+            return GetParamVal<ParamType::TTextureEnvTarget, T>(value);
+        case ParamType::TTextureID:
+            return GetParamVal<ParamType::TTextureID, T>(value);
+        case ParamType::TTextureIDConstPointer:
+            return GetParamVal<ParamType::TTextureIDConstPointer, T>(value);
+        case ParamType::TTextureIDPointer:
+            return GetParamVal<ParamType::TTextureIDPointer, T>(value);
+        case ParamType::TTextureTarget:
+            return GetParamVal<ParamType::TTextureTarget, T>(value);
+        case ParamType::TTextureType:
+            return GetParamVal<ParamType::TTextureType, T>(value);
+        case ParamType::TVertexAttribType:
+            return GetParamVal<ParamType::TVertexAttribType, T>(value);
+        case ParamType::TvoidConstPointer:
+            return GetParamVal<ParamType::TvoidConstPointer, T>(value);
+        case ParamType::TvoidConstPointerPointer:
+            return GetParamVal<ParamType::TvoidConstPointerPointer, T>(value);
+        case ParamType::TvoidPointer:
+            return GetParamVal<ParamType::TvoidPointer, T>(value);
+        case ParamType::TvoidPointerPointer:
+            return GetParamVal<ParamType::TvoidPointerPointer, T>(value);
+    }
+}
+
+template <ParamType PType, typename T>
 void SetParamVal(T valueIn, ParamValue *valueOut);
 
 template <>

src/libGLESv2.gni

@@ -938,6 +938,7 @@ libangle_capture_sources = [
   "src/libANGLE/capture_gles_3_1_params.cpp",
   "src/libANGLE/capture_gles_ext_autogen.cpp",
   "src/libANGLE/capture_gles_ext_params.cpp",
+  "src/libANGLE/frame_capture_replay_autogen.cpp",
   "src/libANGLE/frame_capture_utils_autogen.cpp",
   "src/libANGLE/gl_enum_utils_autogen.cpp",
 ]