/*
 * Copyright (C) 2021 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

/******************************************************************
 *
 * IMPORTANT NOTICE:
 *
 *   This file is part of Android's set of stable system headers
 *   exposed by the Android NDK (Native Development Kit).
 *
 *   Third-party source AND binary code relies on the definitions
 *   here to be FROZEN ON ALL UPCOMING PLATFORM RELEASES.
 *
 *   - DO NOT MODIFY ENUMS (EXCEPT IF YOU ADD NEW 32-BIT VALUES)
 *   - DO NOT MODIFY CONSTANTS OR FUNCTIONAL MACROS
 *   - DO NOT CHANGE THE SIGNATURE OF FUNCTIONS IN ANY WAY
 *   - DO NOT CHANGE THE LAYOUT OR SIZE OF STRUCTURES
 */

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#include <NeuralNetworksTypes.h>

__BEGIN_DECLS

/**
 * Performance information for the reference workload.
 *
 * Used by a driver to report its performance characteristics.
 */
typedef struct {
    /**
     * Ratio of the time taken by the driver to execute the workload compared to the time the CPU
     * would take for the same workload. A lower number is better.
     */
    float execTime;

    /**
     * Ratio of the energy used by the driver compared to what the CPU would use for doing the same
     * workload. A lower number is better.
     */
    float powerUsage;
} SL_ANeuralNetworksPerformanceInfo;

/**
 * Driver performance when operating on a particular data type. In the case of float32 data, this is
 * used when the calculations are not relaxed.
 */
typedef struct {
    int32_t operandType;
    SL_ANeuralNetworksPerformanceInfo performanceInfo;
} SL_ANeuralNetworksOperandPerformanceInfo;

/**
 * Information about NNAPI Vendor extension operand type.
 */
typedef struct {
    /**
     * The byte size of the operand (if scalar) or of a single element (if tensor).
     */
    uint32_t byteSize;

    /**
     * The extension operand type.
     */
    uint16_t type;

    /**
     * Indicates whether the extension operand type represents a tensor or a scalar.
     */
    bool isTensor;
} SL_ANeuralNetworksExtensionOperandTypeInformation;

/**
 * The different performance info kinds.
 */
typedef enum {
    /**
     * Driver performance when operating on float32 data but performing calculations with range
     * and/or precision as low as that of the IEEE 754 16-bit floating-point format.
     */
    SL_ANEURALNETWORKS_CAPABILITIES_PERFORMANCE_RELAXED_SCALAR = 0,

    /**
     * Driver performance when operating on float32 data but performing calculations with range
     * and/or precision as low as that of the IEEE 754 16-bit floating-point format.
     */
    SL_ANEURALNETWORKS_CAPABILITIES_PERFORMANCE_RELAXED_TENSOR = 1,

    /**
     * Performance of an {@link ANEURALNETWORKS_IF} operation is the sum of {@link
     * ANEURALNETWORKS_IF}'s performance and the mean of performance for the two branch subgraphs,
     * where performance for a subgraph is the sum of the performance of all operations within the
     * subgraph.
     */
    SL_ANEURALNETWORKS_CAPABILITIES_PERFORMANCE_IF = 2,

    /**
     * Performance of a {@link ANEURALNETWORKS_WHILE} operation is the sum of {@link
     * ANEURALNETWORKS_WHILE}'s performance, performance for the condition subgraph and performance
     * for the body subgraph, where performance for a subgraph is the sum of the performance of all
     * operations within the subgraph.
     */
    SL_ANEURALNETWORKS_CAPABILITIES_PERFORMANCE_WHILE = 3,
} SL_ANeuralNetworksPerformanceInfoCode;

/**
 * Sets the compilation caching signature and file descriptors.
 *
 * Provides optional caching information to the support library driver for
 * faster repeated compilation.
 *
 * See {@link ANeuralNetworksCompilation} for information on multithreaded usage.
 *
 * @param compilation The compilation to be modified.
 * @param modelCacheFds An array of file descriptors for the security-sensitive cache.
 *                      The file descriptors will be duplicated.
 * @param numModelCacheFiles The number of the model cache files.
 * @param dataCacheFds An array of file descriptors for the constants' cache.
 *                     The file descriptors will be duplicated.
 * @param numDataCacheFiles The number of the data cache files.
 * @param token The token provided by the user to specify a model must be of length
 *              ANEURALNETWORKS_BYTE_SIZE_OF_CACHE_TOKEN. The user should ensure that
 *              the token is unique to a model within the application. The NNAPI
 *              runtime cannot detect token collisions; a collision will result in a
 *              failed execution or in a successful execution that produces incorrect
 *              output values.
 *
 * @return ANEURALNETWORKS_NO_ERROR if successful.
 *
 * Available in the compabibility library build only.
 */
int SL_ANeuralNetworksCompilation_setCachingFromFds(ANeuralNetworksCompilation* compilation,
                                                    const int* modelCacheFds,
                                                    const uint32_t numModelCacheFiles,
                                                    const int* dataCacheFds,
                                                    const uint32_t numDataCacheFiles,
                                                    const uint8_t* token);

/**
 * Gets the caching requirements of the driver implementation.
 *
 * There are two types of cache file descriptors provided to the driver: model cache and data cache.
 *
 * The data cache is for caching constant data, possibly including preprocessed and transformed
 * tensor buffers. Any modification to the data cache should have no worse effect than generating
 * bad output values at execution time.
 *
 * The model cache is for caching security-sensitive data such as compiled executable machine code
 * in the device's native binary format. A modification to the model cache may affect the driver's
 * execution behavior, and a malicious client could make use of this to execute beyond the granted
 * permission.
 *
 * ANeuralNetworksDevice_getNumberOfCacheFilesNeeded returns how many of each type of cache files
 * the driver implementation needs to cache a single compilation. Returning 0 for both types
 * indicates compilation caching is not supported by this driver. The driver may still choose not to
 * cache certain compiled models even if it reports that caching is supported.
 *
 * @param device The representation of the specified device.
 * @param numModelCacheFiles The number of the model cache files. A value of 0 is returned on error.
 * @param numDataCacheFiles The number of the data cache files. A value of 0 is returned on error.
 *
 * @return ANEURALNETWORKS_NO_ERROR if successful.
 *
 * Available in the compabibility library build only.
 */
int SL_ANeuralNetworksDevice_getNumberOfCacheFilesNeeded(const ANeuralNetworksDevice* device,
                                                         uint32_t* numModelCacheFiles,
                                                         uint32_t* numDataCacheFiles);

/**
 * Get NNAPI Device performance/power capabilities.
 *
 * This returns performance of non-extension operations.
 *
 * Performance of an operation other than {@link ANEURALNETWORKS_IF} and {@link
 * ANEURALNETWORKS_WHILE} comes from the type of its first operand.
 *
 * @param device The representation of the specified device.
 * @param performanceInfoKind The kind of performance info to be queried. Must be one of the values
 *                            from {@link SL_ANeuralNetworksPerformanceInfoCode}.
 * @return ANEURALNETWORKS_NO_ERROR if successful.
 *
 * Available in the compabibility library build only.
 */
int SL_ANeuralNetworksDevice_getPerformanceInfo(const ANeuralNetworksDevice* device,
                                                int32_t performanceInfoKind,
                                                SL_ANeuralNetworksPerformanceInfo* performanceInfo);

/**
 * Get NNAPI Device operand performance/power capabilities.
 *
 * This returns performance of non-extension operations.
 *
 * Performance of an operation other than {@link ANEURALNETWORKS_IF} and {@link
 * ANEURALNETWORKS_WHILE} comes from the type of its first operand.
 *
 * @param device The representation of the specified device.
 * @param context Context to pass to the callback.
 * @param callback Callback taking operand performance and context.
 * @return ANEURALNETWORKS_NO_ERROR if successful.
 *
 * Available in the compabibility library build only.
 */
int SL_ANeuralNetworksDevice_forEachOperandPerformanceInfo(
        const ANeuralNetworksDevice* device, void* context,
        void (*callback)(SL_ANeuralNetworksOperandPerformanceInfo, void*));

/**
 * Get the number of extensions supported by the driver implementation.
 *
 * @param device The representation of the specified device.
 * @param vendorExtensionCount The number of vendor extensions the device supports. To be used in
 *                             {@link ANeuralNetworksDevice_getVendorExtensionName} and {@link
 *                             ANeuralNetworksDevice_forEachVendorExtensionOperandTypeInformation}.
 * @return ANEURALNETWORKS_NO_ERROR if successful.
 *
 * Available in the compabibility library build only.
 */
int SL_ANeuralNetworksDevice_getVendorExtensionCount(const ANeuralNetworksDevice* device,
                                                     uint32_t* vendorExtensionCount);

/**
 * Gets information about a specified extension supported by the driver implementation.
 *
 * @param device The representation of the specified device.
 * @param vendorExtensionIndex The index of the specified vendor extension. Must be less than the
 *                             number of available vendor extensions.
 * @param extensionName Name of the NNAPI HAL Extension.
 * @return ANEURALNETWORKS_NO_ERROR if successful.
 *
 * Available in the compabibility library build only.
 */
int SL_ANeuralNetworksDevice_getVendorExtensionName(const ANeuralNetworksDevice* device,
                                                    uint32_t vendorExtensionIndex,
                                                    const char** extensionName);

/**
 * Gets a specified extension's operand type information supported by the driver implementation.
 *
 * @param device The representation of the specified device.
 * @param vendorExtensionIndex The index of the specified vendor extension. Must be less than the
 *                             number of available vendor extensions.
 * @param context Context to pass to the callback.
 * @param callback Callback taking operand type information and context.
 * @return ANEURALNETWORKS_NO_ERROR if successful.
 *
 * Available in the compabibility library build only.
 */
int SL_ANeuralNetworksDevice_forEachVendorExtensionOperandTypeInformation(
        const ANeuralNetworksDevice* device, uint32_t vendorExtensionIndex, void* context,
        void (*callback)(SL_ANeuralNetworksExtensionOperandTypeInformation, void*));

/**
 * Base version of NnApiSLDriverImpl with version information.
 *
 * NnApiSLDriverImpl is non-opaque, versioning struct to make it possible to pass
 * its instance straight from the SL Driver to the shim registration. The glue code
 * that loads the SL and calls the shim is non-updatable. An opaque struct would require the
 * glue code to be updated if we would like to use newer NNAPI Feature Level.
 *
 * There's expectation that for M>N, NnApiSLDriverImplFL(M) is
 * a strict superset of NnApiSLDriverImplFL(N), and NnApiSLDriverImplFL(M)* can
 * be reinterpret_cast to NnApiSLDriverImplFL(N)* safely.
 */
typedef struct {
    /**
     * Version of the NnApiSLDriverImpl struct. Uses {@link FeatureLevelCode} values
     * for versioning.
     */
    int64_t implFeatureLevel;
} NnApiSLDriverImpl;

/**
 * NnApiSLDriverImpl for an Updatable SL Driver implementing {@link
 * ANEURALNETWORKS_FEATURE_LEVEL_5}.
 *
 * This struct must set its implFeatureLevel to {@link ANEURALNETWORKS_FEATURE_LEVEL_5}.
 */
typedef struct {
    /**
     * Base type with version information. Allows to cast a pointer of this type
     * to NnApiSLDriverImpl* with valid version information.
     * For this type, its .version fields should be always set to {@link
     * ANEURALNETWORKS_FEATURE_LEVEL_5}.
     */
    NnApiSLDriverImpl base;

    /**
     * SL Driver implementation of {@link ANeuralNetworksBurst_create}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksBurst_create},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksBurst_create)(ANeuralNetworksCompilation* compilation,
                                       ANeuralNetworksBurst** burst);

    /**
     * SL Driver implementation of {@link ANeuralNetworksBurst_free}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksBurst_free},
     * at the feature level of this NnApiSLDriver struct.
     */
    void (*ANeuralNetworksBurst_free)(ANeuralNetworksBurst* burst);

    /**
     * SL Driver implementation of {@link ANeuralNetworksCompilation_createForDevices}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksCompilation_createForDevices},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksCompilation_createForDevices)(ANeuralNetworksModel* model,
                                                       const ANeuralNetworksDevice* const* devices,
                                                       uint32_t numDevices,
                                                       ANeuralNetworksCompilation** compilation);

    /**
     * SL Driver implementation of {@link ANeuralNetworksCompilation_finish}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksCompilation_finish},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksCompilation_finish)(ANeuralNetworksCompilation* compilation);

    /**
     * SL Driver implementation of {@link ANeuralNetworksCompilation_free}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksCompilation_free},
     * at the feature level of this NnApiSLDriver struct.
     */
    void (*ANeuralNetworksCompilation_free)(ANeuralNetworksCompilation* compilation);

    /**
     * SL Driver implementation of {@link
     * ANeuralNetworksCompilation_getPreferredMemoryAlignmentForInput}. Behavior, arguments, and
     * outputs match NNAPI Runtime function
     * {@link ANeuralNetworksCompilation_getPreferredMemoryAlignmentForInput},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksCompilation_getPreferredMemoryAlignmentForInput)(
            const ANeuralNetworksCompilation* compilation, uint32_t index, uint32_t* alignment);

    /**
     * SL Driver implementation of {@link
     * ANeuralNetworksCompilation_getPreferredMemoryAlignmentForOutput}. Behavior, arguments, and
     * outputs match NNAPI Runtime function
     * {@link ANeuralNetworksCompilation_getPreferredMemoryAlignmentForOutput},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksCompilation_getPreferredMemoryAlignmentForOutput)(
            const ANeuralNetworksCompilation* compilation, uint32_t index, uint32_t* alignment);

    /**
     * SL Driver implementation of {@link
     * ANeuralNetworksCompilation_getPreferredMemoryPaddingForInput}. Behavior, arguments, and
     * outputs match NNAPI Runtime function
     * {@link ANeuralNetworksCompilation_getPreferredMemoryPaddingForInput},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksCompilation_getPreferredMemoryPaddingForInput)(
            const ANeuralNetworksCompilation* compilation, uint32_t index, uint32_t* padding);

    /**
     * SL Driver implementation of {@link
     * ANeuralNetworksCompilation_getPreferredMemoryPaddingForOutput}. Behavior, arguments, and
     * outputs match NNAPI Runtime function
     * {@link ANeuralNetworksCompilation_getPreferredMemoryPaddingForOutput},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksCompilation_getPreferredMemoryPaddingForOutput)(
            const ANeuralNetworksCompilation* compilation, uint32_t index, uint32_t* padding);

    /**
     * SL Driver implementation of {@link ANeuralNetworksCompilation_setCaching}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksCompilation_setCaching},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksCompilation_setCaching)(ANeuralNetworksCompilation* compilation,
                                                 const char* cacheDir, const uint8_t* token);

    /**
     * SL Driver implementation of {@link ANeuralNetworksCompilation_setPreference}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksCompilation_setPreference},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksCompilation_setPreference)(ANeuralNetworksCompilation* compilation,
                                                    int32_t preference);

    /**
     * SL Driver implementation of {@link ANeuralNetworksCompilation_setPriority}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksCompilation_setPriority},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksCompilation_setPriority)(ANeuralNetworksCompilation* compilation,
                                                  int priority);

    /**
     * SL Driver implementation of {@link ANeuralNetworksCompilation_setTimeout}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksCompilation_setTimeout},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksCompilation_setTimeout)(ANeuralNetworksCompilation* compilation,
                                                 uint64_t duration);

    /**
     * SL Driver implementation of {@link ANeuralNetworksDevice_getExtensionSupport}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksDevice_getExtensionSupport},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksDevice_getExtensionSupport)(const ANeuralNetworksDevice* device,
                                                     const char* extensionName,
                                                     bool* isExtensionSupported);

    /**
     * SL Driver implementation of {@link ANeuralNetworksDevice_getFeatureLevel}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksDevice_getFeatureLevel},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksDevice_getFeatureLevel)(const ANeuralNetworksDevice* device,
                                                 int64_t* featureLevel);

    /**
     * SL Driver implementation of {@link ANeuralNetworksDevice_getName}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksDevice_getName},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksDevice_getName)(const ANeuralNetworksDevice* device, const char** name);

    /**
     * SL Driver implementation of {@link ANeuralNetworksDevice_getType}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksDevice_getType},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksDevice_getType)(const ANeuralNetworksDevice* device, int32_t* type);

    /**
     * SL Driver implementation of {@link ANeuralNetworksDevice_getVersion}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksDevice_getVersion},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksDevice_getVersion)(const ANeuralNetworksDevice* device,
                                            const char** version);

    /**
     * SL Driver implementation of {@link ANeuralNetworksDevice_wait}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksDevice_wait},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksDevice_wait)(const ANeuralNetworksDevice* device);

    /**
     * SL Driver implementation of {@link ANeuralNetworksEvent_createFromSyncFenceFd}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksEvent_createFromSyncFenceFd},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksEvent_createFromSyncFenceFd)(int sync_fence_fd,
                                                      ANeuralNetworksEvent** event);

    /**
     * SL Driver implementation of {@link ANeuralNetworksEvent_free}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksEvent_free},
     * at the feature level of this NnApiSLDriver struct.
     */
    void (*ANeuralNetworksEvent_free)(ANeuralNetworksEvent* event);

    /**
     * SL Driver implementation of {@link ANeuralNetworksEvent_getSyncFenceFd}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksEvent_getSyncFenceFd},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksEvent_getSyncFenceFd)(const ANeuralNetworksEvent* event,
                                               int* sync_fence_fd);

    /**
     * SL Driver implementation of {@link ANeuralNetworksEvent_wait}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksEvent_wait},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksEvent_wait)(ANeuralNetworksEvent* event);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_burstCompute}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_burstCompute},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_burstCompute)(ANeuralNetworksExecution* execution,
                                                 ANeuralNetworksBurst* burst);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_compute}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_compute},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_compute)(ANeuralNetworksExecution* execution);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_create}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_create},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_create)(ANeuralNetworksCompilation* compilation,
                                           ANeuralNetworksExecution** execution);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_enableInputAndOutputPadding}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_enableInputAndOutputPadding},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_enableInputAndOutputPadding)(ANeuralNetworksExecution* execution,
                                                                bool enable);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_free}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_free},
     * at the feature level of this NnApiSLDriver struct.
     */
    void (*ANeuralNetworksExecution_free)(ANeuralNetworksExecution* execution);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_getDuration}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_getDuration},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_getDuration)(const ANeuralNetworksExecution* execution,
                                                int32_t durationCode, uint64_t* duration);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_getOutputOperandDimensions}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_getOutputOperandDimensions},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_getOutputOperandDimensions)(ANeuralNetworksExecution* execution,
                                                               int32_t index, uint32_t* dimensions);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_getOutputOperandRank}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_getOutputOperandRank},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_getOutputOperandRank)(ANeuralNetworksExecution* execution,
                                                         int32_t index, uint32_t* rank);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_setInput}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_setInput},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_setInput)(ANeuralNetworksExecution* execution, int32_t index,
                                             const ANeuralNetworksOperandType* type,
                                             const void* buffer, size_t length);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_setInputFromMemory}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_setInputFromMemory},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_setInputFromMemory)(ANeuralNetworksExecution* execution,
                                                       int32_t index,
                                                       const ANeuralNetworksOperandType* type,
                                                       const ANeuralNetworksMemory* memory,
                                                       size_t offset, size_t length);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_setLoopTimeout}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_setLoopTimeout},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_setLoopTimeout)(ANeuralNetworksExecution* execution,
                                                   uint64_t duration);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_setMeasureTiming}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_setMeasureTiming},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_setMeasureTiming)(ANeuralNetworksExecution* execution,
                                                     bool measure);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_setOutput}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_setOutput},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_setOutput)(ANeuralNetworksExecution* execution, int32_t index,
                                              const ANeuralNetworksOperandType* type, void* buffer,
                                              size_t length);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_setOutputFromMemory}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_setOutputFromMemory},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_setOutputFromMemory)(ANeuralNetworksExecution* execution,
                                                        int32_t index,
                                                        const ANeuralNetworksOperandType* type,
                                                        const ANeuralNetworksMemory* memory,
                                                        size_t offset, size_t length);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_setReusable}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_setReusable},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_setReusable)(ANeuralNetworksExecution* execution, bool reusable);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_setTimeout}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_setTimeout},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_setTimeout)(ANeuralNetworksExecution* execution,
                                               uint64_t duration);

    /**
     * SL Driver implementation of {@link ANeuralNetworksExecution_startComputeWithDependencies}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksExecution_startComputeWithDependencies},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksExecution_startComputeWithDependencies)(
            ANeuralNetworksExecution* execution, const ANeuralNetworksEvent* const* dependencies,
            uint32_t num_dependencies, uint64_t duration, ANeuralNetworksEvent** event);

    /**
     * SL Driver implementation of {@link ANeuralNetworksMemoryDesc_addInputRole}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksMemoryDesc_addInputRole},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksMemoryDesc_addInputRole)(ANeuralNetworksMemoryDesc* desc,
                                                  const ANeuralNetworksCompilation* compilation,
                                                  uint32_t index, float frequency);

    /**
     * SL Driver implementation of {@link ANeuralNetworksMemoryDesc_addOutputRole}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksMemoryDesc_addOutputRole},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksMemoryDesc_addOutputRole)(ANeuralNetworksMemoryDesc* desc,
                                                   const ANeuralNetworksCompilation* compilation,
                                                   uint32_t index, float frequency);

    /**
     * SL Driver implementation of {@link ANeuralNetworksMemoryDesc_create}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksMemoryDesc_create},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksMemoryDesc_create)(ANeuralNetworksMemoryDesc** desc);

    /**
     * SL Driver implementation of {@link ANeuralNetworksMemoryDesc_finish}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksMemoryDesc_finish},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksMemoryDesc_finish)(ANeuralNetworksMemoryDesc* desc);

    /**
     * SL Driver implementation of {@link ANeuralNetworksMemoryDesc_free}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksMemoryDesc_free},
     * at the feature level of this NnApiSLDriver struct.
     */
    void (*ANeuralNetworksMemoryDesc_free)(ANeuralNetworksMemoryDesc* desc);

    /**
     * SL Driver implementation of {@link ANeuralNetworksMemoryDesc_setDimensions}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksMemoryDesc_setDimensions},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksMemoryDesc_setDimensions)(ANeuralNetworksMemoryDesc* desc, uint32_t rank,
                                                   const uint32_t* dimensions);

    /**
     * SL Driver implementation of {@link ANeuralNetworksMemory_copy}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksMemory_copy},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksMemory_copy)(const ANeuralNetworksMemory* src,
                                      const ANeuralNetworksMemory* dst);

    /**
     * SL Driver implementation of {@link ANeuralNetworksMemory_createFromAHardwareBuffer}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksMemory_createFromAHardwareBuffer},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksMemory_createFromAHardwareBuffer)(const AHardwareBuffer* ahwb,
                                                           ANeuralNetworksMemory** memory);

    /**
     * SL Driver implementation of {@link ANeuralNetworksMemory_createFromDesc}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksMemory_createFromDesc},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksMemory_createFromDesc)(const ANeuralNetworksMemoryDesc* desc,
                                                ANeuralNetworksMemory** memory);

    /**
     * SL Driver implementation of {@link ANeuralNetworksMemory_createFromFd}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksMemory_createFromFd},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksMemory_createFromFd)(size_t size, int protect, int fd, size_t offset,
                                              ANeuralNetworksMemory** memory);

    /**
     * SL Driver implementation of {@link ANeuralNetworksMemory_free}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksMemory_free},
     * at the feature level of this NnApiSLDriver struct.
     */
    void (*ANeuralNetworksMemory_free)(ANeuralNetworksMemory* memory);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_addOperand}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_addOperand},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_addOperand)(ANeuralNetworksModel* model,
                                           const ANeuralNetworksOperandType* type);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_addOperation}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_addOperation},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_addOperation)(ANeuralNetworksModel* model,
                                             ANeuralNetworksOperationType type, uint32_t inputCount,
                                             const uint32_t* inputs, uint32_t outputCount,
                                             const uint32_t* outputs);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_create}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_create},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_create)(ANeuralNetworksModel** model);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_finish}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_finish},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_finish)(ANeuralNetworksModel* model);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_free}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_free},
     * at the feature level of this NnApiSLDriver struct.
     */
    void (*ANeuralNetworksModel_free)(ANeuralNetworksModel* model);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_getExtensionOperandType}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_getExtensionOperandType},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_getExtensionOperandType)(ANeuralNetworksModel* model,
                                                        const char* extensionName,
                                                        uint16_t operandCodeWithinExtension,
                                                        int32_t* type);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_getExtensionOperationType}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_getExtensionOperationType},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_getExtensionOperationType)(ANeuralNetworksModel* model,
                                                          const char* extensionName,
                                                          uint16_t operationCodeWithinExtension,
                                                          ANeuralNetworksOperationType* type);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_getSupportedOperationsForDevices}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_getSupportedOperationsForDevices},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_getSupportedOperationsForDevices)(
            const ANeuralNetworksModel* model, const ANeuralNetworksDevice* const* devices,
            uint32_t numDevices, bool* supportedOps);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_identifyInputsAndOutputs}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_identifyInputsAndOutputs},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_identifyInputsAndOutputs)(ANeuralNetworksModel* model,
                                                         uint32_t inputCount,
                                                         const uint32_t* inputs,
                                                         uint32_t outputCount,
                                                         const uint32_t* outputs);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_relaxComputationFloat32toFloat16}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_relaxComputationFloat32toFloat16},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_relaxComputationFloat32toFloat16)(ANeuralNetworksModel* model,
                                                                 bool allow);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_setOperandExtensionData}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_setOperandExtensionData},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_setOperandExtensionData)(ANeuralNetworksModel* model, int32_t index,
                                                        const void* data, size_t length);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_setOperandSymmPerChannelQuantParams}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_setOperandSymmPerChannelQuantParams},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_setOperandSymmPerChannelQuantParams)(
            ANeuralNetworksModel* model, int32_t index,
            const ANeuralNetworksSymmPerChannelQuantParams* channelQuant);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_setOperandValue}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_setOperandValue},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_setOperandValue)(ANeuralNetworksModel* model, int32_t index,
                                                const void* buffer, size_t length);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_setOperandValueFromMemory}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_setOperandValueFromMemory},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_setOperandValueFromMemory)(ANeuralNetworksModel* model,
                                                          int32_t index,
                                                          const ANeuralNetworksMemory* memory,
                                                          size_t offset, size_t length);

    /**
     * SL Driver implementation of {@link ANeuralNetworksModel_setOperandValueFromModel}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksModel_setOperandValueFromModel},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworksModel_setOperandValueFromModel)(ANeuralNetworksModel* model, int32_t index,
                                                         const ANeuralNetworksModel* value);

    /**
     * SL Driver implementation of {@link ANeuralNetworks_getDefaultLoopTimeout}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworks_getDefaultLoopTimeout},
     * at the feature level of this NnApiSLDriver struct.
     */
    uint64_t (*ANeuralNetworks_getDefaultLoopTimeout)();

    /**
     * SL Driver implementation of {@link ANeuralNetworks_getDevice}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworks_getDevice},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworks_getDevice)(uint32_t devIndex, ANeuralNetworksDevice** device);

    /**
     * SL Driver implementation of {@link ANeuralNetworks_getDeviceCount}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworks_getDeviceCount},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*ANeuralNetworks_getDeviceCount)(uint32_t* numDevices);

    /**
     * SL Driver implementation of {@link ANeuralNetworks_getMaximumLoopTimeout}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworks_getMaximumLoopTimeout},
     * at the feature level of this NnApiSLDriver struct.
     */
    uint64_t (*ANeuralNetworks_getMaximumLoopTimeout)();

    /**
     * SL Driver implementation of {@link ANeuralNetworks_getRuntimeFeatureLevel}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link ANeuralNetworks_getRuntimeFeatureLevel},
     * at the feature level of this NnApiSLDriver struct.
     */
    int64_t (*ANeuralNetworks_getRuntimeFeatureLevel)();

    /**
     * SL Driver implementation of a function similar to
     * {@link ANeuralNetworksCompilation_setCaching} that takes file descriptors
     * instead of a cache directory.
     * Behavior and outputs match NNAPI Runtime function
     * {@link ANeuralNetworksCompilation_setCaching},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*SL_ANeuralNetworksCompilation_setCachingFromFds)(ANeuralNetworksCompilation* compilation,
                                                           const int* modelCacheFds,
                                                           const uint32_t numModelCacheFiles,
                                                           const int* dataCacheFds,
                                                           const uint32_t numDataCacheFiles,
                                                           const uint8_t* token);

    /**
     * SL Driver implementation of {@link SL_ANeuralNetworksDevice_getNumberOfCacheFilesNeeded}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link SL_ANeuralNetworksDevice_getNumberOfCacheFilesNeeded},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*SL_ANeuralNetworksDevice_getNumberOfCacheFilesNeeded)(const ANeuralNetworksDevice* device,
                                                                uint32_t* numModelCacheFiles,
                                                                uint32_t* numDataCacheFiles);

    /**
     * SL Driver implementation of {@link SL_ANeuralNetworksDevice_getPerformanceInfo}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link SL_ANeuralNetworksDevice_getPerformanceInfo},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*SL_ANeuralNetworksDevice_getPerformanceInfo)(
            const ANeuralNetworksDevice* device, int32_t performanceInfoKind,
            SL_ANeuralNetworksPerformanceInfo* performanceInfo);

    /**
     * SL Driver implementation of {@link
     * SL_ANeuralNetworksDevice_forEachOperandPerformanceInfo}. Behavior, arguments, and
     * outputs match NNAPI Runtime function
     * {@link SL_ANeuralNetworksDevice_forEachOperandPerformanceInfo},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*SL_ANeuralNetworksDevice_forEachOperandPerformanceInfo)(
            const ANeuralNetworksDevice* device, void* context,
            void (*callback)(SL_ANeuralNetworksOperandPerformanceInfo, void*));

    /**
     * SL Driver implementation of {@link SL_ANeuralNetworksDevice_getVendorExtensionCount}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link SL_ANeuralNetworksDevice_getVendorExtensionCount},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*SL_ANeuralNetworksDevice_getVendorExtensionCount)(const ANeuralNetworksDevice* device,
                                                            uint32_t* vendorExtensionCount);

    /**
     * SL Driver implementation of {@link SL_ANeuralNetworksDevice_getVendorExtensionName}.
     * Behavior, arguments, and outputs match NNAPI Runtime function
     * {@link SL_ANeuralNetworksDevice_getVendorExtensionName},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*SL_ANeuralNetworksDevice_getVendorExtensionName)(const ANeuralNetworksDevice* device,
                                                           uint32_t vendorExtensionIndex,
                                                           const char** extensionName);

    /**
     * SL Driver implementation of {@link
     * SL_ANeuralNetworksDevice_forEachVendorExtensionOperandTypeInformation}. Behavior, arguments,
     * and outputs match NNAPI Runtime function
     * {@link SL_ANeuralNetworksDevice_forEachVendorExtensionOperandTypeInformation},
     * at the feature level of this NnApiSLDriver struct.
     */
    int (*SL_ANeuralNetworksDevice_forEachVendorExtensionOperandTypeInformation)(
            const ANeuralNetworksDevice* device, uint32_t vendorExtensionIndex, void* context,
            void (*callback)(SL_ANeuralNetworksExtensionOperandTypeInformation, void*));
} NnApiSLDriverImplFL5;

__END_DECLS