FrameCapture.h - mozsearch

mozilla-central/gfx/angle/checkout/src/libANGLE/capture/FrameCapture.h (file symbol)

Enable keyboard shortcuts

Source code

File a bug in Core :: Graphics

Revision control

Copy as Markdown

Other Tools

//

// 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_