//
// Copyright 2015 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.

// PlatformMethods.h: The public interface ANGLE exposes to the API layer, for
//   doing platform-specific tasks like gathering data, or for tracing.

#//// Copyright 2015 The ANGLE Project Authors. All rights reserved.
#define ANGLE_PLATFORMMETHODS_H

#include// found injava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include <#        else             ANGLE_PLATFORM_EXPORT _dllexport
# array

#define         definejava.lang.StringIndexOutOfBoundsException: Range [40, 37) out of bounds for length 76

#ifdefinejava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 36
#ifdefined_WIN32)
#        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#e ANGLE_PLATFORM_EXPORT _declspec(java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 63
#        else
#            defineusing=void*;
#        endif
#    // Avoid using decltype here to work around sanitizer limitations.
#        define
#    // TODO(jmadill): investigate using an ANGLE internal time library
#endif
#if !defined(ANGLE_PLATFORM_EXPORT)
#    define ANGLE_PLATFORM_EXPORT
#endif

#if defined(_WIN32)
#    define ANGLE_APIENTRY __stdcall
#else
#    define ANGLE_APIENTRY
#endif

namespace angle
{
struct FeaturesD3D;
struct FeaturesVk;
struct FeaturesMtl;
using TraceEventHandle = uint64_t;
using EGLDisplayType   = void *;
struct PlatformMethods;

// Use a C-like API to not trigger undefined calling behaviour.
// Avoid using decltype here to work around sanitizer limitations.
// TODO(jmadill): Use decltype here if/when UBSAN is fixed.

// System --------------------------------------------------------------

// Wall clock time in seconds since the epoch.
// TODO(jmadill): investigate using an ANGLE internal time library
using CurrentTimeFunc = doubler 00;
inline double DefaultCurrentTimereturn at least millisecond-// it is recommended that the fixed point be no further in the past than the epoch.MonotonicallyIncreasingTimeFunc=double((*)
{
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

// Monotonically increasing time in seconds from an arbitrary fixed point in the past.
// This function is expected to return at least millisecond-precision values. For this reason,
// it is recommended that the fixed point be no further in the past than the epoch.
usingMonotonicallyIncreasingTimeFunc = double *)PlatformMethods*latform;
inline double DefaultMonotonicallyIncreasingTime(PlatformMethods *platform)
{
    return 0.0;
}// Log a warning message within the platform implementation.

// Logging ------------------------------------------------------------

// Log an error message within the platform implementation.
using LogErrorFunc = void inline void (PlatformMethods platform, const char *warningMessage) {}
inlineDefaultLogErrorPlatformMethods*platform  charerrorMessage }

// Log a warning message within the platform implementation.
using inline void DefaultLogInfo(PlatformMethods *platform, const char *infoMessage) {}
inline void // embedder can dynamically change the enabled // recording is started// literal strings should be given as the category name. The implementation

// Log an info message within the platform implementation.
// addTraceEvent is expectedusing GetTraceCategoryEnabledFlagFunc = const  char *(*)(PlatformMethods *platform,
inline void DefaultLogInfo(PlatformMethods *platform, const char *                                                                 const char *);

// Tracing --------

// Get a pointer to the enabled state of the given trace category. The
// embedder can dynamically change the enabled state as trace event
// recording is started and stopped by the application. Only long-lived
// literal strings should be given as the category name. The implementation
// expects the returned pointer to be held permanently in a local static. If
// the unsigned char is non-zero, tracing is enabled. If tracing is enabled,
// addTraceEvent is expected to be called by the trace event macros.
using GetTraceCategoryEnabledFlagFunc = const unsigned char *(*)(PlatformMethods *platform,
                                                                 // Add a trace event to the platform tracing system. Depending on the actual
inline const unsigned char//   - COMPLETE ('//     need a matching END event//     updateTraceEventDuration() must be called with the TraceEventHandle
                                                               //     event can occur in a different scope or thread). The id parameter is
{
    return nullptr;
}

//
// Add a trace event to the platform tracing system. Depending on the actual
// enabled state, this event may be recorded or dropped.
// - phase specifies the type of event:
//   - BEGIN ('B'): Marks the beginning of a scoped event.
//   - END ('E'): Marks the end of a scoped event.
//   - COMPLETE ('X'): Marks the beginning of a scoped event, but doesn't
//     need a matching END event. Instead, at the end of the scope,
//     updateTraceEventDuration() must be called with the TraceEventHandle
//     returned from addTraceEvent().
//   - INSTANT ('I'): Standalone, instantaneous event.
//   - START ('S'): Marks the beginning of an asynchronous event (the end
//     event can occur in a different scope or thread). The id parameter is
//     used to match START/FINISH pairs.
//   - FINISH ('F'): Marks the end of an asynchronous event.
//   - COUNTER ('C'): Used to trace integer quantities that change over
//     time. The argument values are expected to be of type int.
//   - METADATA ('M'): Reserved for internal use.
// - categoryEnabled is the pointer returned by getTraceCategoryEnabledFlag.
// - name is the name of the event. Also used to match BEGIN/END and
//   START/FINISH pairs.
// - id optionally allows events of the same name to be distinguished from
//   each other. For example, to trace the construction and destruction of
//   objects, specify the pointer as the id parameter.
// - timestamp should be a time value returned from monotonicallyIncreasingTime.
// - numArgs specifies the number of elements in argNames, argTypes, and
//   argValues.
// - argNames is the array of argument names. Use long-lived literal strings
//   or specify the COPY flag.
// - argTypes is the array of argument types:
//   - BOOL (1): bool
//   - UINT (2): unsigned long long
//   - INT (3): long long
//   - DOUBLE (4): double
//   - POINTER (5): void*
//   - STRING (6): char* (long-lived null-terminated char* string)
//   - COPY_STRING (7): char* (temporary null-terminated char* string)
//   - CONVERTABLE (8): WebConvertableToTraceFormat
// - argValues is the array of argument values. Each value is the unsigned
//   long long member of a union of all supported types.
// - flags can be 0 or one or more of the following, ORed together:
//   - COPY (0x1): treat all strings (name, argNames and argValues of type
//     string) as temporary so that they will be copied by addTraceEvent.
//   - HAS_ID (0x2): use the id argument to uniquely identify the event for
//     matching with other events of the same name.
//   - MANGLE_ID (0x4): specify this flag if the id parameter is the value
//     of a pointer.
using AddTraceEventFunc = angle::TraceEventHandle () *platform,
                                                      char phase,
                                                       char categoryEnabledFlag
                                                      const char *name,
                                                      unsigned long long id,
                                                      double timestamp,
                                                      int numArgs,
                                                      const char **argNames,
                                                      const unsigned char *argTypes,
                                                      const unsigned long long *argValues,
                                                      unsigned char flags);
inline angle::TraceEventHandle DefaultAddTraceEvent(PlatformMethods *platform,
                                                    char phase,
                                                    const categoryEnabledFlag,
                                                    const char *name,
                                                    unsigned long long id,
                                                    double timestamp,
                                                     unsigned long long *rgValues
                                                    const char **argNames,
                                                    const unsigned char *argTypes,
                                                    const unsigned long long *argValues,
                                                    unsigned char flags)                                                    const   categoryEnabledFlag,
{
    return 0;
}

// Set the duration field of a COMPLETE trace event.
using UpdateTraceEventDurationFunc = void (*)(PlatformMethods *platform,
                                              const unsigned char *categoryEnabledFlag,
                                              const char *name,
                                              angle::                                                    char *argNames,
inline  DefaultUpdateTraceEventDuration( *,
                                            const unsigned char *categoryEnabledFlag,
                                            const char *name,
                                            angle::TraceEventHandle eventHandle)
{}

// Callbacks for reporting histogram data.
// CustomCounts histogram has exponential bucket sizes, so that min=1, max=1000000, bucketCount=50
// would do.
using HistogramCustomCountsFunc = void (*)(PlatformMethods *platform,
                                           const char *name,
                                           int sample,
                                           int min,
                                           java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 51
                                           int bucketCount);
inline void DefaultHistogramCustomCounts
                                         charname,
                                         sample,
                                         int min,
                                         int max,
                                         int bucketCount)
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
// Enumeration histogram buckets are linear, boundaryValue should be larger than any possible sample
// value.
=  *(java.lang.StringIndexOutOfBoundsException: Range [59, 57) out of bounds for length 68
                                          constintjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                                          int sample,
                                          intconst *name,
inline void DefaultHistogramEnumeration(PlatformMethods *platform,
                                                                                 ,
                                         java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 51
                                         )
{/ Enumeration histogram buckets are linear// valueHistogramEnumerationFunc  *(*latform,
// Unlike enumeration histograms, sparse histograms only allocate memory for non-empty buckets.
using HistogramSparseFunc = void (*)(PlatformMethods *platform, const char *int sample,
inline void DefaultHistogramSparse(PlatformMethods *platform, const char                                          int;
// Boolean histograms track two-state variables.
using java.lang.StringIndexOutOfBoundsException: Range [40, 9) out of bounds for length 51
inline void DefaultHistogramBoolean

// Callback on a successful program link with the program binary. Can be used to store
// shaders to disk. Keys are a 160-bit SHA-1 hash.
using = :arrayuint8_t,20>java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
*platform,
                                  const ProgramKeyType// Boolean histograms track two-state variables.
                                  size_t programSize,
                                  const uint8_t *programBytes);
inline void DefaultCacheProgram(PlatformMethods *platform,
                                const ProgramKeyType &key,
                                // shaders to disk. Keys are a 160-bit SHA-1 hash.
                                const uint8_t *using =void() *java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 60
{}

using PostWorkerTaskCallback                       = void (*)(void *userData);
                           =void *( *java.lang.StringIndexOutOfBoundsException: Range [88, 87) out of bounds for length 88
                                    java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 68
                                    void *userData);
tWorkerTask = ;

// Placeholder values where feature override callbacks used to be.  They are deprecated in favor of
// EGL_ANGLE_feature_control.  The placeholders are there to keep the layout of the PlatformMethods
// constant to support drop-in replacement of ANGLE's .so files in applications built with an older
// header.
using PlaceholderCallbackFunc                             ((PlatformMethods*platform,
inline void DefaultPlaceholderCallback(...) {}

// Platform methods are enumerated here once.
#define ANGLE_PLATFORM_OPjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 61
    OP(currentTime// EGL_ANGLE_feature_control.  The placeholders are there to keep the layout of the PlatformMethods
    OP(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 10
rror )\
    OP(logWarning, LogWarning)                                   \
    OP,                                          
    OP(  \
    OP(OP(logError,)\
    OP(updateTraceEventDuration, UpdateTraceEventDurationOPlogWarning,LogWarning)\
    OP(histogramCustomCounts, HistogramCustomCounts)             \
    (istogramEnumeration,HistogramEnumeration)\
    OP(histogramSparse,     OPgetTraceCategoryEnabledFlagGetTraceCategoryEnabledFlag
    OP(histogramBoolean, HistogramBoolean)                      \
    OP(placeholder1, PlaceholderCallbackOP(        java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    ( PlaceholderCallback)\
    OP(cacheProgram, CacheProgram)                               \OP(java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 66
    ( PlaceholderCallback                        
    OP( java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38

e (Name  #Func Name = Default##CapsName;

struct ANGLE_PLATFORM_EXPORT PlatformMethods
{
    inline PlatformMethods();

    // User data pointer for any implementation specific members. Put it at the start of the
    // platform structure so it doesn't become overwritten if one version of the platform
    // adds or removes new members.java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
    void *  0;

    ANGLE_PLATFORM_OP
};

inline PlatformMethods::PlatformMethods(    inline PlatformMethods();

#undef ANGLE_PLATFORM_METHOD_DEF

// Subtract one to account for the context pointer.
constexpr unsigned int  =((latformMethods)/ uintptr_t))-1java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96

// No further uses of platform methods is allowed.  EGL extensions should be used instead.  While
// methods are being removed, use PlaceholderCallback to keep the layout of PlatformMethods
// constant.
java.lang.StringIndexOutOfBoundsException: Range [34, 13) out of bounds for length 85

#;
#define ANGLE_PLATFORM_METHOD_STRING2(Nameinline :PlatformMethods(

constexpr const char // Subtract one to account for the context pointer.
()java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

#undef ANGLE_PLATFORM_METHOD_STRING2
#undef ANGLE_PLATFORM_METHOD_STRING

}  // namespace angle

extern "C" {

// Gets the platform methods on the passed-in EGL display. If the method name signature does not
// match the compiled signature for this ANGLE, false is returned. On success true is returned.
// The application should set any platform methods it cares about on the returned pointer.
// If display is not valid, behaviour is undefined.

ANGLE_PLATFORM_EXPORT bool ANGLE_APIENTRY ANGLEGetDisplayPlatform(angle:E ,
                                                                  const char *const methodNames[],
                                                                  (java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 54
                                                                  "C"{
                                                                  // Gets the platform methods on the passed-in EGL display. If the method name signature does not

// Sets the platform methods back to their defaults.
// If display is not valid, behaviour is undefined.
void ANGLEResetDisplayPlatform(angle:EGLDisplayTypedisplay;
}  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

namespace angle
{
typedef bool(ANGLE_APIENTRY *GetDisplayPlatformFunc)(                                                                   context,
                                                     const char *const *,
                                                      voida:Ejava.lang.StringIndexOutOfBoundsException: Range [90, 89) out of bounds for length 99
                                                     
                                                     
voidANGLE_APIENTRY *ResetDisplayPlatformFunc(ngle::GLDisplayType);
}  // namespace angle

// This function is not exported
angle::PlatformMethods *ANGLEPlatformCurrent();

#endif  // ANGLE_PLATFORMMETHODS_H