tor-browser

FrameCapture.h (46304B)

---

//
// Copyright 2019 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.
//
// FrameCapture.h:
//   ANGLE Frame capture interface.
//

#ifndef LIBANGLE_FRAME_CAPTURE_H_
#define LIBANGLE_FRAME_CAPTURE_H_

#include "common/PackedEnums.h"
#include "common/system_utils.h"
#include "libANGLE/Context.h"
#include "libANGLE/angletypes.h"
#include "libANGLE/capture/frame_capture_utils_autogen.h"
#include "libANGLE/entry_points_utils.h"

namespace gl
{
enum class BigGLEnum;
enum class GLESEnum;
}  // namespace gl

namespace angle
{

using ParamData = std::vector<std::vector<uint8_t>>;
struct ParamCapture : angle::NonCopyable
{
   ParamCapture();
   ParamCapture(const char *nameIn, ParamType typeIn);
   ~ParamCapture();

   ParamCapture(ParamCapture &&other);
   ParamCapture &operator=(ParamCapture &&other);

   std::string name;
   ParamType type;
   ParamValue value;
   gl::GLESEnum enumGroup;   // only used for param type GLenum, GLboolean and GLbitfield
   gl::BigGLEnum bigGLEnum;  // only used for param type GLenum, GLboolean and GLbitfield
   ParamData data;
   int dataNElements           = 0;
   int arrayClientPointerIndex = -1;
   size_t readBufferSizeBytes  = 0;
};

class ParamBuffer final : angle::NonCopyable
{
 public:
   ParamBuffer();
   ~ParamBuffer();

   ParamBuffer(ParamBuffer &&other);
   ParamBuffer &operator=(ParamBuffer &&other);

   template <typename T>
   void addValueParam(const char *paramName, ParamType paramType, T paramValue);
   template <typename T>
   void setValueParamAtIndex(const char *paramName, ParamType paramType, T paramValue, int index);
   template <typename T>
   void addEnumParam(const char *paramName,
                     gl::GLESEnum enumGroup,
                     ParamType paramType,
                     T paramValue);
   template <typename T>
   void addEnumParam(const char *paramName,
                     gl::BigGLEnum enumGroup,
                     ParamType paramType,
                     T paramValue);

   ParamCapture &getParam(const char *paramName, ParamType paramType, int index);
   const ParamCapture &getParam(const char *paramName, ParamType paramType, int index) const;
   ParamCapture &getParamFlexName(const char *paramName1,
                                  const char *paramName2,
                                  ParamType paramType,
                                  int index);
   const ParamCapture &getParamFlexName(const char *paramName1,
                                        const char *paramName2,
                                        ParamType paramType,
                                        int index) const;
   const ParamCapture &getReturnValue() const { return mReturnValueCapture; }

   void addParam(ParamCapture &&param);
   void addReturnValue(ParamCapture &&returnValue);
   bool hasClientArrayData() const { return mClientArrayDataParam != -1; }
   ParamCapture &getClientArrayPointerParameter();
   size_t getReadBufferSize() const { return mReadBufferSize; }

   const std::vector<ParamCapture> &getParamCaptures() const { return mParamCaptures; }

   // These helpers allow us to track the ID of the buffer that was active when
   // MapBufferRange was called.  We'll use it during replay to track the
   // buffer's contents, as they can be modified by the host.
   void setMappedBufferID(gl::BufferID bufferID) { mMappedBufferID = bufferID; }
   gl::BufferID getMappedBufferID() const { return mMappedBufferID; }

 private:
   std::vector<ParamCapture> mParamCaptures;
   ParamCapture mReturnValueCapture;
   int mClientArrayDataParam = -1;
   size_t mReadBufferSize    = 0;
   gl::BufferID mMappedBufferID;
};

struct CallCapture
{
   CallCapture(EntryPoint entryPointIn, ParamBuffer &&paramsIn);
   CallCapture(const std::string &customFunctionNameIn, ParamBuffer &&paramsIn);
   ~CallCapture();

   CallCapture(CallCapture &&other);
   CallCapture &operator=(CallCapture &&other);

   const char *name() const;

   EntryPoint entryPoint;
   std::string customFunctionName;
   ParamBuffer params;
   bool isActive = true;
};

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;
};

// Helper to use unique IDs for each local data variable.
class DataCounters final : angle::NonCopyable
{
 public:
   DataCounters();
   ~DataCounters();

   int getAndIncrement(EntryPoint entryPoint, const std::string &paramName);

 private:
   // <CallName, ParamName>
   using Counter = std::pair<EntryPoint, std::string>;
   std::map<Counter, int> mData;
};

constexpr int kStringsNotFound = -1;
class StringCounters final : angle::NonCopyable
{
 public:
   StringCounters();
   ~StringCounters();

   int getStringCounter(const std::vector<std::string> &str);
   void setStringCounter(const std::vector<std::string> &str, int &counter);

 private:
   std::map<std::vector<std::string>, int> mStringCounterMap;
};

class DataTracker final : angle::NonCopyable
{
 public:
   DataTracker();
   ~DataTracker();

   DataCounters &getCounters() { return mCounters; }
   StringCounters &getStringCounters() { return mStringCounters; }

 private:
   DataCounters mCounters;
   StringCounters mStringCounters;
};

class ReplayWriter final : angle::NonCopyable
{
 public:
   ReplayWriter();
   ~ReplayWriter();

   void setSourceFileSizeThreshold(size_t sourceFileSizeThreshold);
   void setFilenamePattern(const std::string &pattern);
   void setCaptureLabel(const std::string &label);
   void setSourcePrologue(const std::string &prologue);
   void setHeaderPrologue(const std::string &prologue);

   void addPublicFunction(const std::string &functionProto,
                          const std::stringstream &headerStream,
                          const std::stringstream &bodyStream);
   void addPrivateFunction(const std::string &functionProto,
                           const std::stringstream &headerStream,
                           const std::stringstream &bodyStream);
   std::string getInlineVariableName(EntryPoint entryPoint, const std::string &paramName);

   std::string getInlineStringSetVariableName(EntryPoint entryPoint,
                                              const std::string &paramName,
                                              const std::vector<std::string> &strings,
                                              bool *isNewEntryOut);

   void saveFrame();
   void saveFrameIfFull();
   void saveIndexFilesAndHeader();
   void saveSetupFile();

   std::vector<std::string> getAndResetWrittenFiles();

 private:
   static std::string GetVarName(EntryPoint entryPoint, const std::string &paramName, int counter);

   void saveHeader();
   void writeReplaySource(const std::string &filename);
   void addWrittenFile(const std::string &filename);
   size_t getStoredReplaySourceSize() const;

   size_t mSourceFileSizeThreshold;
   size_t mFrameIndex;

   DataTracker mDataTracker;
   std::string mFilenamePattern;
   std::string mCaptureLabel;
   std::string mSourcePrologue;
   std::string mHeaderPrologue;

   std::vector<std::string> mReplayHeaders;
   std::vector<std::string> mGlobalVariableDeclarations;

   std::vector<std::string> mPublicFunctionPrototypes;
   std::vector<std::string> mPublicFunctions;

   std::vector<std::string> mPrivateFunctionPrototypes;
   std::vector<std::string> mPrivateFunctions;

   std::vector<std::string> mWrittenFiles;
};

using BufferCalls = std::map<GLuint, std::vector<CallCapture>>;

// true means mapped, false means unmapped
using BufferMapStatusMap = std::map<GLuint, bool>;

using FenceSyncSet   = std::set<GLsync>;
using FenceSyncCalls = std::map<GLsync, std::vector<CallCapture>>;

// For default uniforms, we need to track which ones are dirty, and the series of calls to reset.
// Each program has unique default uniforms, and each uniform has one or more locations in the
// default buffer. For reset efficiency, we track only the uniforms dirty by location, per program.

// A set of all default uniforms (per program) that were modified during the run
using DefaultUniformLocationsSet = std::set<gl::UniformLocation>;
using DefaultUniformLocationsPerProgramMap =
   std::map<gl::ShaderProgramID, DefaultUniformLocationsSet>;

// A map of programs which maps to locations and their reset calls
using DefaultUniformCallsPerLocationMap = std::map<gl::UniformLocation, std::vector<CallCapture>>;
using DefaultUniformCallsPerProgramMap =
   std::map<gl::ShaderProgramID, DefaultUniformCallsPerLocationMap>;

using DefaultUniformBaseLocationMap =
   std::map<std::pair<gl::ShaderProgramID, gl::UniformLocation>, gl::UniformLocation>;

using ResourceSet   = std::set<GLuint>;
using ResourceCalls = std::map<GLuint, std::vector<CallCapture>>;

class TrackedResource final : angle::NonCopyable
{
 public:
   TrackedResource();
   ~TrackedResource();

   const ResourceSet &getStartingResources() const { return mStartingResources; }
   ResourceSet &getStartingResources() { return mStartingResources; }
   const ResourceSet &getNewResources() const { return mNewResources; }
   ResourceSet &getNewResources() { return mNewResources; }
   const ResourceSet &getResourcesToRegen() const { return mResourcesToRegen; }
   ResourceSet &getResourcesToRegen() { return mResourcesToRegen; }
   const ResourceSet &getResourcesToRestore() const { return mResourcesToRestore; }
   ResourceSet &getResourcesToRestore() { return mResourcesToRestore; }

   void setGennedResource(GLuint id);
   void setDeletedResource(GLuint id);
   void setModifiedResource(GLuint id);
   bool resourceIsGenerated(GLuint id);

   ResourceCalls &getResourceRegenCalls() { return mResourceRegenCalls; }
   ResourceCalls &getResourceRestoreCalls() { return mResourceRestoreCalls; }

 private:
   // Resource regen calls will gen a resource
   ResourceCalls mResourceRegenCalls;
   // Resource restore calls will restore the contents of a resource
   ResourceCalls mResourceRestoreCalls;

   // Resources created during startup
   ResourceSet mStartingResources;

   // Resources created during the run that need to be deleted
   ResourceSet mNewResources;
   // Resources deleted during the run that need to be recreated
   ResourceSet mResourcesToRegen;
   // Resources modified during the run that need to be restored
   ResourceSet mResourcesToRestore;
};

using TrackedResourceArray =
   std::array<TrackedResource, static_cast<uint32_t>(ResourceIDType::EnumCount)>;

// Helper to track resource changes during the capture
class ResourceTracker final : angle::NonCopyable
{
 public:
   ResourceTracker();
   ~ResourceTracker();

   BufferCalls &getBufferMapCalls() { return mBufferMapCalls; }
   BufferCalls &getBufferUnmapCalls() { return mBufferUnmapCalls; }

   std::vector<CallCapture> &getBufferBindingCalls() { return mBufferBindingCalls; }

   void setBufferMapped(gl::ContextID contextID, GLuint id);
   void setBufferUnmapped(gl::ContextID contextID, GLuint id);

   bool getStartingBuffersMappedCurrent(GLuint id) const;
   bool getStartingBuffersMappedInitial(GLuint id) const;

   void setStartingBufferMapped(GLuint id, bool mapped)
   {
       // Track the current state (which will change throughout the trace)
       mStartingBuffersMappedCurrent[id] = mapped;

       // And the initial state, to compare during frame loop reset
       mStartingBuffersMappedInitial[id] = mapped;
   }

   void onShaderProgramAccess(gl::ShaderProgramID shaderProgramID);
   uint32_t getMaxShaderPrograms() const { return mMaxShaderPrograms; }

   FenceSyncSet &getStartingFenceSyncs() { return mStartingFenceSyncs; }
   FenceSyncCalls &getFenceSyncRegenCalls() { return mFenceSyncRegenCalls; }
   FenceSyncSet &getFenceSyncsToRegen() { return mFenceSyncsToRegen; }
   void setDeletedFenceSync(GLsync sync);

   DefaultUniformLocationsPerProgramMap &getDefaultUniformsToReset()
   {
       return mDefaultUniformsToReset;
   }
   DefaultUniformCallsPerLocationMap &getDefaultUniformResetCalls(gl::ShaderProgramID id)
   {
       return mDefaultUniformResetCalls[id];
   }
   void setModifiedDefaultUniform(gl::ShaderProgramID programID, gl::UniformLocation location);
   void setDefaultUniformBaseLocation(gl::ShaderProgramID programID,
                                      gl::UniformLocation location,
                                      gl::UniformLocation baseLocation);
   gl::UniformLocation getDefaultUniformBaseLocation(gl::ShaderProgramID programID,
                                                     gl::UniformLocation location)
   {
       ASSERT(mDefaultUniformBaseLocations.find({programID, location}) !=
              mDefaultUniformBaseLocations.end());
       return mDefaultUniformBaseLocations[{programID, location}];
   }

   TrackedResource &getTrackedResource(gl::ContextID contextID, ResourceIDType type);

   void getContextIDs(std::set<gl::ContextID> &idsOut);

   std::map<void *, egl::AttributeMap> &getImageToAttribTable() { return mMatchImageToAttribs; }

   std::map<GLuint, void *> &getTextureIDToImageTable() { return mMatchTextureIDToImage; }

 private:
   // Buffer map calls will map a buffer with correct offset, length, and access flags
   BufferCalls mBufferMapCalls;
   // Buffer unmap calls will bind and unmap a given buffer
   BufferCalls mBufferUnmapCalls;

   // Buffer binding calls to restore bindings recorded during MEC
   std::vector<CallCapture> mBufferBindingCalls;

   // Whether a given buffer was mapped at the start of the trace
   BufferMapStatusMap mStartingBuffersMappedInitial;
   // The status of buffer mapping throughout the trace, modified with each Map/Unmap call
   BufferMapStatusMap mStartingBuffersMappedCurrent;

   // Maximum accessed shader program ID.
   uint32_t mMaxShaderPrograms = 0;

   // Fence sync objects created during MEC setup
   FenceSyncSet mStartingFenceSyncs;
   // Fence sync regen calls will create a fence sync objects
   FenceSyncCalls mFenceSyncRegenCalls;
   // Fence syncs to regen are a list of starting fence sync objects that were deleted and need to
   // be regen'ed.
   FenceSyncSet mFenceSyncsToRegen;

   // Default uniforms that were modified during the run
   DefaultUniformLocationsPerProgramMap mDefaultUniformsToReset;
   // Calls per default uniform to return to original state
   DefaultUniformCallsPerProgramMap mDefaultUniformResetCalls;

   // Base location of arrayed uniforms
   DefaultUniformBaseLocationMap mDefaultUniformBaseLocations;

   // Tracked resources per context
   TrackedResourceArray mTrackedResourcesShared;
   std::map<gl::ContextID, TrackedResourceArray> mTrackedResourcesPerContext;

   std::map<void *, egl::AttributeMap> mMatchImageToAttribs;
   std::map<GLuint, void *> mMatchTextureIDToImage;
};

// Used by the CPP replay to filter out unnecessary code.
using HasResourceTypeMap = angle::PackedEnumBitSet<ResourceIDType>;

// Map of ResourceType to IDs and range of setup calls
using ResourceIDToSetupCallsMap =
   PackedEnumMap<ResourceIDType, std::map<GLuint, gl::Range<size_t>>>;

// Map of buffer ID to offset and size used when mapped
using BufferDataMap = std::map<gl::BufferID, std::pair<GLintptr, GLsizeiptr>>;

// A dictionary of sources indexed by shader type.
using ProgramSources = gl::ShaderMap<std::string>;

// Maps from IDs to sources.
using ShaderSourceMap  = std::map<gl::ShaderProgramID, std::string>;
using ProgramSourceMap = std::map<gl::ShaderProgramID, ProgramSources>;

// Map from textureID to level and data
using TextureLevels       = std::map<GLint, std::vector<uint8_t>>;
using TextureLevelDataMap = std::map<gl::TextureID, TextureLevels>;

struct SurfaceParams
{
   gl::Extents extents;
   egl::ColorSpace colorSpace;
};

// Map from ContextID to SurfaceParams
using SurfaceParamsMap = std::map<gl::ContextID, SurfaceParams>;

using CallVector = std::vector<std::vector<CallCapture> *>;

// A map from API entry point to calls
using CallResetMap = std::map<angle::EntryPoint, std::vector<CallCapture>>;

// StateResetHelper provides a simple way to track whether an entry point has been called during the
// trace, along with the reset calls to get it back to starting state.  This is useful for things
// that are one dimensional, like context bindings or context state.
class StateResetHelper final : angle::NonCopyable
{
 public:
   StateResetHelper();
   ~StateResetHelper();

   const std::set<angle::EntryPoint> &getDirtyEntryPoints() const { return mDirtyEntryPoints; }
   void setEntryPointDirty(EntryPoint entryPoint) { mDirtyEntryPoints.insert(entryPoint); }

   CallResetMap &getResetCalls() { return mResetCalls; }
   const CallResetMap &getResetCalls() const { return mResetCalls; }

   void setDefaultResetCalls(const gl::Context *context, angle::EntryPoint);

 private:
   // Dirty state per entry point
   std::set<angle::EntryPoint> mDirtyEntryPoints;

   // Reset calls per API entry point
   CallResetMap mResetCalls;
};

class FrameCapture final : angle::NonCopyable
{
 public:
   FrameCapture();
   ~FrameCapture();

   std::vector<CallCapture> &getSetupCalls() { return mSetupCalls; }
   void clearSetupCalls() { mSetupCalls.clear(); }

   StateResetHelper &getStateResetHelper() { return mStateResetHelper; }

   void reset();

 private:
   std::vector<CallCapture> mSetupCalls;

   StateResetHelper mStateResetHelper;
};

// Page range inside a coherent buffer
struct PageRange
{
   PageRange(size_t start, size_t end);
   ~PageRange();

   // Relative start page
   size_t start;

   // First page after the relative end
   size_t end;
};

// Memory address range defined by start and size
struct AddressRange
{
   AddressRange();
   AddressRange(uintptr_t start, size_t size);
   ~AddressRange();

   uintptr_t end();

   uintptr_t start;
   size_t size;
};

// Used to handle protection of buffers that overlap in pages.
enum class PageSharingType
{
   NoneShared,
   FirstShared,
   LastShared,
   FirstAndLastShared
};

class CoherentBuffer
{
 public:
   CoherentBuffer(uintptr_t start, size_t size, size_t pageSize);
   ~CoherentBuffer();

   // Sets the a range in the buffer clean and protects a selected range
   void protectPageRange(const PageRange &pageRange);

   // Sets a page dirty state and sets it's protection
   void setDirty(size_t relativePage, bool dirty);

   // Removes protection
   void removeProtection(PageSharingType sharingType);

   bool contains(size_t page, size_t *relativePage);
   bool isDirty();

   // Returns dirty page ranges
   std::vector<PageRange> getDirtyPageRanges();

   // Calculates address range from page range
   AddressRange getDirtyAddressRange(const PageRange &dirtyPageRange);
   AddressRange getRange();

 private:
   // Actual buffer start and size
   AddressRange mRange;

   // Start and size of page aligned protected area
   AddressRange mProtectionRange;

   // Start and end of protection in relative pages, calculated from mProtectionRange.
   size_t mProtectionStartPage;
   size_t mProtectionEndPage;

   size_t mPageCount;
   size_t mPageSize;

   // Clean pages are protected
   std::vector<bool> mDirtyPages;
};

class CoherentBufferTracker final : angle::NonCopyable
{
 public:
   CoherentBufferTracker();
   ~CoherentBufferTracker();

   bool isDirty(gl::BufferID id);
   void addBuffer(gl::BufferID id, uintptr_t start, size_t size);
   void removeBuffer(gl::BufferID id);
   void disable();
   void enable();
   void onEndFrame();

 private:
   // Detect overlapping pages when removing protection
   PageSharingType doesBufferSharePage(gl::BufferID id);

   // Returns a map to found buffers and the corresponding pages for a given address.
   // For addresses that are in a page shared by 2 buffers, 2 results are returned.
   HashMap<std::shared_ptr<CoherentBuffer>, size_t> getBufferPagesForAddress(uintptr_t address);
   PageFaultHandlerRangeType handleWrite(uintptr_t address);
   bool haveBuffer(gl::BufferID id);

 public:
   std::mutex mMutex;
   HashMap<GLuint, std::shared_ptr<CoherentBuffer>> mBuffers;

 private:
   bool mEnabled = false;
   std::unique_ptr<PageFaultHandler> mPageFaultHandler;
   size_t mPageSize;
};

// Shared class for any items that need to be tracked by FrameCapture across shared contexts
class FrameCaptureShared final : angle::NonCopyable
{
 public:
   FrameCaptureShared();
   ~FrameCaptureShared();

   void captureCall(const gl::Context *context, CallCapture &&call, bool isCallValid);
   void checkForCaptureTrigger();
   void onEndFrame(const gl::Context *context);
   void onDestroyContext(const gl::Context *context);
   void onMakeCurrent(const gl::Context *context, const egl::Surface *drawSurface);
   bool enabled() const { return mEnabled; }

   bool isCapturing() const;
   void replay(gl::Context *context);
   uint32_t getFrameCount() const;

   // Returns a frame index starting from "1" as the first frame.
   uint32_t getReplayFrameIndex() const;

   void trackBufferMapping(const gl::Context *context,
                           CallCapture *call,
                           gl::BufferID id,
                           gl::Buffer *buffer,
                           GLintptr offset,
                           GLsizeiptr length,
                           bool writable,
                           bool coherent);

   void trackTextureUpdate(const gl::Context *context, const CallCapture &call);
   void trackDefaultUniformUpdate(const gl::Context *context, const CallCapture &call);
   void trackVertexArrayUpdate(const gl::Context *context, const CallCapture &call);

   const std::string &getShaderSource(gl::ShaderProgramID id) const;
   void setShaderSource(gl::ShaderProgramID id, std::string sources);

   const ProgramSources &getProgramSources(gl::ShaderProgramID id) const;
   void setProgramSources(gl::ShaderProgramID id, ProgramSources sources);

   // Load data from a previously stored texture level
   const std::vector<uint8_t> &retrieveCachedTextureLevel(gl::TextureID id,
                                                          gl::TextureTarget target,
                                                          GLint level);

   // Create new texture level data and copy the source into it
   void copyCachedTextureLevel(const gl::Context *context,
                               gl::TextureID srcID,
                               GLint srcLevel,
                               gl::TextureID dstID,
                               GLint dstLevel,
                               const CallCapture &call);

   // Create the location that should be used to cache texture level data
   std::vector<uint8_t> &getCachedTextureLevelData(gl::Texture *texture,
                                                   gl::TextureTarget target,
                                                   GLint level,
                                                   EntryPoint entryPoint);

   // Capture coherent buffer storages
   void captureCoherentBufferSnapshot(const gl::Context *context, gl::BufferID bufferID);

   // Remove any cached texture levels on deletion
   void deleteCachedTextureLevelData(gl::TextureID id);

   void eraseBufferDataMapEntry(const gl::BufferID bufferId)
   {
       const auto &bufferDataInfo = mBufferDataMap.find(bufferId);
       if (bufferDataInfo != mBufferDataMap.end())
       {
           mBufferDataMap.erase(bufferDataInfo);
       }
   }

   bool hasBufferData(gl::BufferID bufferID)
   {
       const auto &bufferDataInfo = mBufferDataMap.find(bufferID);
       if (bufferDataInfo != mBufferDataMap.end())
       {
           return true;
       }
       return false;
   }

   std::pair<GLintptr, GLsizeiptr> getBufferDataOffsetAndLength(gl::BufferID bufferID)
   {
       const auto &bufferDataInfo = mBufferDataMap.find(bufferID);
       ASSERT(bufferDataInfo != mBufferDataMap.end());
       return bufferDataInfo->second;
   }

   void setCaptureActive() { mCaptureActive = true; }
   void setCaptureInactive() { mCaptureActive = false; }
   bool isCaptureActive() { return mCaptureActive; }
   bool usesMidExecutionCapture() { return mCaptureStartFrame > 1; }

   gl::ContextID getWindowSurfaceContextID() const { return mWindowSurfaceContextID; }

   void markResourceSetupCallsInactive(std::vector<CallCapture> *setupCalls,
                                       ResourceIDType type,
                                       GLuint id,
                                       gl::Range<size_t> range);

   void updateReadBufferSize(size_t readBufferSize)
   {
       mReadBufferSize = std::max(mReadBufferSize, readBufferSize);
   }

   template <typename ResourceType>
   void handleGennedResource(const gl::Context *context, ResourceType resourceID)
   {
       if (isCaptureActive())
       {
           ResourceIDType idType    = GetResourceIDTypeFromType<ResourceType>::IDType;
           TrackedResource &tracker = mResourceTracker.getTrackedResource(context->id(), idType);
           tracker.setGennedResource(resourceID.value);
       }
   }

   template <typename ResourceType>
   bool resourceIsGenerated(const gl::Context *context, ResourceType resourceID)
   {
       ResourceIDType idType    = GetResourceIDTypeFromType<ResourceType>::IDType;
       TrackedResource &tracker = mResourceTracker.getTrackedResource(context->id(), idType);
       return tracker.resourceIsGenerated(resourceID.value);
   }

   template <typename ResourceType>
   void handleDeletedResource(const gl::Context *context, ResourceType resourceID)
   {
       if (isCaptureActive())
       {
           ResourceIDType idType    = GetResourceIDTypeFromType<ResourceType>::IDType;
           TrackedResource &tracker = mResourceTracker.getTrackedResource(context->id(), idType);
           tracker.setDeletedResource(resourceID.value);
       }
   }

 private:
   void writeJSON(const gl::Context *context);
   void writeCppReplayIndexFiles(const gl::Context *context, bool writeResetContextCall);
   void writeMainContextCppReplay(const gl::Context *context,
                                  const std::vector<CallCapture> &setupCalls,
                                  StateResetHelper &StateResetHelper);

   void captureClientArraySnapshot(const gl::Context *context,
                                   size_t vertexCount,
                                   size_t instanceCount);
   void captureMappedBufferSnapshot(const gl::Context *context, const CallCapture &call);

   void copyCompressedTextureData(const gl::Context *context, const CallCapture &call);
   void captureCompressedTextureData(const gl::Context *context, const CallCapture &call);

   void reset();
   void maybeOverrideEntryPoint(const gl::Context *context,
                                CallCapture &call,
                                std::vector<CallCapture> &newCalls);
   void maybeCapturePreCallUpdates(const gl::Context *context,
                                   CallCapture &call,
                                   std::vector<CallCapture> *shareGroupSetupCalls,
                                   ResourceIDToSetupCallsMap *resourceIDToSetupCalls);
   template <typename ParamValueType>
   void maybeGenResourceOnBind(const gl::Context *context, CallCapture &call);
   void maybeCapturePostCallUpdates(const gl::Context *context);
   void maybeCaptureDrawArraysClientData(const gl::Context *context,
                                         CallCapture &call,
                                         size_t instanceCount);
   void maybeCaptureDrawElementsClientData(const gl::Context *context,
                                           CallCapture &call,
                                           size_t instanceCount);
   void maybeCaptureCoherentBuffers(const gl::Context *context);
   void updateCopyImageSubData(CallCapture &call);
   void overrideProgramBinary(const gl::Context *context,
                              CallCapture &call,
                              std::vector<CallCapture> &outCalls);
   void updateResourceCountsFromParamCapture(const ParamCapture &param, ResourceIDType idType);
   void updateResourceCountsFromCallCapture(const CallCapture &call);

   void runMidExecutionCapture(const gl::Context *context);

   void scanSetupCalls(const gl::Context *context, std::vector<CallCapture> &setupCalls);

   static void ReplayCall(gl::Context *context,
                          ReplayContext *replayContext,
                          const CallCapture &call);

   std::vector<CallCapture> mFrameCalls;
   gl::ContextID mLastContextId;

   // We save one large buffer of binary data for the whole CPP replay.
   // This simplifies a lot of file management.
   std::vector<uint8_t> mBinaryData;

   bool mEnabled;
   bool mSerializeStateEnabled;
   std::string mOutDirectory;
   std::string mCaptureLabel;
   bool mCompression;
   gl::AttribArray<int> mClientVertexArrayMap;
   uint32_t mFrameIndex;
   uint32_t mCaptureStartFrame;
   uint32_t mCaptureEndFrame;
   bool mIsFirstFrame   = true;
   bool mWroteIndexFile = false;
   SurfaceParamsMap mDrawSurfaceParams;
   gl::AttribArray<size_t> mClientArraySizes;
   size_t mReadBufferSize;
   HasResourceTypeMap mHasResourceType;
   ResourceIDToSetupCallsMap mResourceIDToSetupCalls;
   BufferDataMap mBufferDataMap;
   bool mValidateSerializedState = false;
   std::string mValidationExpression;
   bool mTrimEnabled = true;
   PackedEnumMap<ResourceIDType, uint32_t> mMaxAccessedResourceIDs;
   CoherentBufferTracker mCoherentBufferTracker;

   ResourceTracker mResourceTracker;
   ReplayWriter mReplayWriter;

   // If you don't know which frame you want to start capturing at, use the capture trigger.
   // Initialize it to the number of frames you want to capture, and then clear the value to 0 when
   // you reach the content you want to capture. Currently only available on Android.
   uint32_t mCaptureTrigger;

   bool mCaptureActive;
   std::vector<uint32_t> mActiveFrameIndices;

   // Cache most recently compiled and linked sources.
   ShaderSourceMap mCachedShaderSource;
   ProgramSourceMap mCachedProgramSources;

   gl::ContextID mWindowSurfaceContextID;

   std::vector<CallCapture> mShareGroupSetupCalls;
};

template <typename CaptureFuncT, typename... ArgsT>
void CaptureCallToFrameCapture(CaptureFuncT captureFunc,
                              bool isCallValid,
                              gl::Context *context,
                              ArgsT... captureParams)
{
   FrameCaptureShared *frameCaptureShared = context->getShareGroup()->getFrameCaptureShared();
   if (!frameCaptureShared->isCapturing())
   {
       return;
   }

   CallCapture call = captureFunc(context->getState(), isCallValid, captureParams...);

   frameCaptureShared->captureCall(context, std::move(call), isCallValid);
}

template <typename T>
void ParamBuffer::addValueParam(const char *paramName, ParamType paramType, T paramValue)
{
   ParamCapture capture(paramName, paramType);
   InitParamValue(paramType, paramValue, &capture.value);
   mParamCaptures.emplace_back(std::move(capture));
}

template <typename T>
void ParamBuffer::setValueParamAtIndex(const char *paramName,
                                      ParamType paramType,
                                      T paramValue,
                                      int index)
{
   ASSERT(mParamCaptures.size() > static_cast<size_t>(index));

   ParamCapture capture(paramName, paramType);
   InitParamValue(paramType, paramValue, &capture.value);
   mParamCaptures[index] = std::move(capture);
}

template <typename T>
void ParamBuffer::addEnumParam(const char *paramName,
                              gl::GLESEnum enumGroup,
                              ParamType paramType,
                              T paramValue)
{
   ParamCapture capture(paramName, paramType);
   InitParamValue(paramType, paramValue, &capture.value);
   capture.enumGroup = enumGroup;
   mParamCaptures.emplace_back(std::move(capture));
}

template <typename T>
void ParamBuffer::addEnumParam(const char *paramName,
                              gl::BigGLEnum enumGroup,
                              ParamType paramType,
                              T paramValue)
{
   ParamCapture capture(paramName, paramType);
   InitParamValue(paramType, paramValue, &capture.value);
   capture.bigGLEnum = enumGroup;
   mParamCaptures.emplace_back(std::move(capture));
}

// Pointer capture helpers.
void CaptureMemory(const void *source, size_t size, ParamCapture *paramCapture);
void CaptureString(const GLchar *str, ParamCapture *paramCapture);
void CaptureStringLimit(const GLchar *str, uint32_t limit, ParamCapture *paramCapture);
void CaptureVertexPointerGLES1(const gl::State &glState,
                              gl::ClientVertexArrayType type,
                              const void *pointer,
                              ParamCapture *paramCapture);

gl::Program *GetProgramForCapture(const gl::State &glState, gl::ShaderProgramID handle);

// For GetIntegerv, GetFloatv, etc.
void CaptureGetParameter(const gl::State &glState,
                        GLenum pname,
                        size_t typeSize,
                        ParamCapture *paramCapture);

void CaptureGetActiveUniformBlockivParameters(const gl::State &glState,
                                             gl::ShaderProgramID handle,
                                             gl::UniformBlockIndex uniformBlockIndex,
                                             GLenum pname,
                                             ParamCapture *paramCapture);

template <typename T>
void CaptureClearBufferValue(GLenum buffer, const T *value, ParamCapture *paramCapture)
{
   // Per the spec, color buffers have a vec4, the rest a single value
   uint32_t valueSize = (buffer == GL_COLOR) ? 4 : 1;
   CaptureMemory(value, valueSize * sizeof(T), paramCapture);
}

void CaptureGenHandlesImpl(GLsizei n, GLuint *handles, ParamCapture *paramCapture);

template <typename T>
void CaptureGenHandles(GLsizei n, T *handles, ParamCapture *paramCapture)
{
   paramCapture->dataNElements = n;
   CaptureGenHandlesImpl(n, reinterpret_cast<GLuint *>(handles), paramCapture);
}

template <typename T>
void CaptureArray(T *elements, GLsizei n, ParamCapture *paramCapture)
{
   paramCapture->dataNElements = n;
   CaptureMemory(elements, n * sizeof(T), paramCapture);
}

void CaptureShaderStrings(GLsizei count,
                         const GLchar *const *strings,
                         const GLint *length,
                         ParamCapture *paramCapture);

template <ParamType ParamT, typename T>
void WriteParamValueReplay(std::ostream &os, const CallCapture &call, T value);

template <>
void WriteParamValueReplay<ParamType::TGLboolean>(std::ostream &os,
                                                 const CallCapture &call,
                                                 GLboolean value);

template <>
void WriteParamValueReplay<ParamType::TGLbooleanPointer>(std::ostream &os,
                                                        const CallCapture &call,
                                                        GLboolean *value);

template <>
void WriteParamValueReplay<ParamType::TvoidConstPointer>(std::ostream &os,
                                                        const CallCapture &call,
                                                        const void *value);

template <>
void WriteParamValueReplay<ParamType::TvoidPointer>(std::ostream &os,
                                                   const CallCapture &call,
                                                   void *value);

template <>
void WriteParamValueReplay<ParamType::TGLfloatConstPointer>(std::ostream &os,
                                                           const CallCapture &call,
                                                           const GLfloat *value);

template <>
void WriteParamValueReplay<ParamType::TGLintConstPointer>(std::ostream &os,
                                                         const CallCapture &call,
                                                         const GLint *value);

template <>
void WriteParamValueReplay<ParamType::TGLsizeiPointer>(std::ostream &os,
                                                      const CallCapture &call,
                                                      GLsizei *value);

template <>
void WriteParamValueReplay<ParamType::TGLuintConstPointer>(std::ostream &os,
                                                          const CallCapture &call,
                                                          const GLuint *value);

template <>
void WriteParamValueReplay<ParamType::TGLDEBUGPROCKHR>(std::ostream &os,
                                                      const CallCapture &call,
                                                      GLDEBUGPROCKHR value);

template <>
void WriteParamValueReplay<ParamType::TGLDEBUGPROC>(std::ostream &os,
                                                   const CallCapture &call,
                                                   GLDEBUGPROC value);

template <>
void WriteParamValueReplay<ParamType::TBufferID>(std::ostream &os,
                                                const CallCapture &call,
                                                gl::BufferID value);

template <>
void WriteParamValueReplay<ParamType::TFenceNVID>(std::ostream &os,
                                                 const CallCapture &call,
                                                 gl::FenceNVID value);

template <>
void WriteParamValueReplay<ParamType::TFramebufferID>(std::ostream &os,
                                                     const CallCapture &call,
                                                     gl::FramebufferID value);

template <>
void WriteParamValueReplay<ParamType::TMemoryObjectID>(std::ostream &os,
                                                      const CallCapture &call,
                                                      gl::MemoryObjectID value);

template <>
void WriteParamValueReplay<ParamType::TProgramPipelineID>(std::ostream &os,
                                                         const CallCapture &call,
                                                         gl::ProgramPipelineID value);

template <>
void WriteParamValueReplay<ParamType::TQueryID>(std::ostream &os,
                                               const CallCapture &call,
                                               gl::QueryID value);

template <>
void WriteParamValueReplay<ParamType::TRenderbufferID>(std::ostream &os,
                                                      const CallCapture &call,
                                                      gl::RenderbufferID value);

template <>
void WriteParamValueReplay<ParamType::TSamplerID>(std::ostream &os,
                                                 const CallCapture &call,
                                                 gl::SamplerID value);

template <>
void WriteParamValueReplay<ParamType::TSemaphoreID>(std::ostream &os,
                                                   const CallCapture &call,
                                                   gl::SemaphoreID value);

template <>
void WriteParamValueReplay<ParamType::TShaderProgramID>(std::ostream &os,
                                                       const CallCapture &call,
                                                       gl::ShaderProgramID value);

template <>
void WriteParamValueReplay<ParamType::TTextureID>(std::ostream &os,
                                                 const CallCapture &call,
                                                 gl::TextureID value);

template <>
void WriteParamValueReplay<ParamType::TTransformFeedbackID>(std::ostream &os,
                                                           const CallCapture &call,
                                                           gl::TransformFeedbackID value);

template <>
void WriteParamValueReplay<ParamType::TVertexArrayID>(std::ostream &os,
                                                     const CallCapture &call,
                                                     gl::VertexArrayID value);

template <>
void WriteParamValueReplay<ParamType::TUniformLocation>(std::ostream &os,
                                                       const CallCapture &call,
                                                       gl::UniformLocation value);

template <>
void WriteParamValueReplay<ParamType::TUniformBlockIndex>(std::ostream &os,
                                                         const CallCapture &call,
                                                         gl::UniformBlockIndex value);

template <>
void WriteParamValueReplay<ParamType::TGLsync>(std::ostream &os,
                                              const CallCapture &call,
                                              GLsync value);

template <>
void WriteParamValueReplay<ParamType::TGLeglImageOES>(std::ostream &os,
                                                     const CallCapture &call,
                                                     GLeglImageOES value);

template <>
void WriteParamValueReplay<ParamType::TGLubyte>(std::ostream &os,
                                               const CallCapture &call,
                                               GLubyte value);

template <>
void WriteParamValueReplay<ParamType::TEGLContext>(std::ostream &os,
                                                  const CallCapture &call,
                                                  EGLContext value);

template <>
void WriteParamValueReplay<ParamType::TEGLDisplay>(std::ostream &os,
                                                  const CallCapture &call,
                                                  EGLContext value);

template <>
void WriteParamValueReplay<ParamType::TEGLSurface>(std::ostream &os,
                                                  const CallCapture &call,
                                                  EGLContext value);

template <>
void WriteParamValueReplay<ParamType::TEGLDEBUGPROCKHR>(std::ostream &os,
                                                       const CallCapture &call,
                                                       EGLDEBUGPROCKHR value);

template <>
void WriteParamValueReplay<ParamType::TEGLGetBlobFuncANDROID>(std::ostream &os,
                                                             const CallCapture &call,
                                                             EGLGetBlobFuncANDROID value);

template <>
void WriteParamValueReplay<ParamType::TEGLSetBlobFuncANDROID>(std::ostream &os,
                                                             const CallCapture &call,
                                                             EGLSetBlobFuncANDROID value);
template <>
void WriteParamValueReplay<ParamType::TEGLClientBuffer>(std::ostream &os,
                                                       const CallCapture &call,
                                                       EGLClientBuffer value);

template <>
void WriteParamValueReplay<ParamType::TEGLConfig>(std::ostream &os,
                                                 const CallCapture &call,
                                                 EGLConfig value);

template <>
void WriteParamValueReplay<ParamType::TEGLSurface>(std::ostream &os,
                                                  const CallCapture &call,
                                                  EGLSurface value);

// General fallback for any unspecific type.
template <ParamType ParamT, typename T>
void WriteParamValueReplay(std::ostream &os, const CallCapture &call, T value)
{
   os << value;
}
}  // namespace angle

template <typename T>
void CaptureTextureAndSamplerParameter_params(GLenum pname,
                                             const T *param,
                                             angle::ParamCapture *paramCapture)
{
   if (pname == GL_TEXTURE_BORDER_COLOR || pname == GL_TEXTURE_CROP_RECT_OES)
   {
       CaptureMemory(param, sizeof(T) * 4, paramCapture);
   }
   else
   {
       CaptureMemory(param, sizeof(T), paramCapture);
   }
}

#endif  // LIBANGLE_FRAME_CAPTURE_H_