android10/frameworks/rs/rsHidlAdaptation.cpp

/*
 * Copyright (C) 2017 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.
 */

#define LOG_TAG "RenderScript HIDL Adaptation"

#include "cpp/rsDispatch.h"
#include "rsHidlAdaptation.h"
#include "rsFallbackAdaptation.h"

#include <cutils/properties.h>
#include <log/log.h>

using ::android::hardware::renderscript::V1_0::IDevice;
using ::android::hardware::renderscript::V1_0::IContext;
using ::android::hardware::renderscript::V1_0::Allocation;
using ::android::hardware::renderscript::V1_0::AllocationCubemapFace;
using ::android::hardware::renderscript::V1_0::AllocationMipmapControl;
using ::android::hardware::renderscript::V1_0::AllocationUsageType;
using ::android::hardware::renderscript::V1_0::Closure;
using ::android::hardware::renderscript::V1_0::ContextType;
using ::android::hardware::renderscript::V1_0::DataKind;
using ::android::hardware::renderscript::V1_0::DataType;
using ::android::hardware::renderscript::V1_0::ForEachStrategy;
using ::android::hardware::renderscript::V1_0::MessageToClientType;
using ::android::hardware::renderscript::V1_0::SamplerValue;
using ::android::hardware::renderscript::V1_0::ScriptCall;
using ::android::hardware::renderscript::V1_0::ScriptFieldID;
using ::android::hardware::renderscript::V1_0::ScriptKernelID;
using ::android::hardware::renderscript::V1_0::ScriptIntrinsicID;
using ::android::hardware::renderscript::V1_0::ThreadPriorities;
using ::android::hardware::renderscript::V1_0::Type;
using ::android::hardware::renderscript::V1_0::YuvFormat;
using ::android::hardware::renderscript::V1_0::Size;
using ::android::hidl::base::V1_0::IBase;
using ::android::hardware::hidl_array;
using ::android::hardware::hidl_memory;
using ::android::hardware::details::hidl_pointer;
using ::android::hardware::hidl_string;
using ::android::hardware::hidl_vec;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::sp;

dispatchTable RsHidlAdaptation::mEntryFuncs;
sp<IDevice> RsHidlAdaptation::mHidl;
std::set<sp<IContext> > RsHidlAdaptation::mContexts;
std::mutex RsHidlAdaptation::mContextsMutex;

static uint32_t getProp(const char *str) {
    char buf[PROPERTY_VALUE_MAX];
    property_get(str, buf, "0");
    return atoi(buf);
}

RsHidlAdaptation::RsHidlAdaptation()
{
    InitializeHalDeviceContext();
}

RsHidlAdaptation& RsHidlAdaptation::GetInstance()
{
    // This function-local-static guarantees the instance is a singleton. The
    // constructor of RsHidlAdaptation will only be called when GetInstance is
    // called for the first time.
    static RsHidlAdaptation instance;
    return instance;
}

const dispatchTable* RsHidlAdaptation::GetEntryFuncs()
{
    return &mEntryFuncs;
}


void RsHidlAdaptation::LoadDispatchForHidl() {
    mEntryFuncs.Allocation1DData = Allocation1DData;
    mEntryFuncs.Allocation1DElementData = Allocation1DElementData;
    mEntryFuncs.Allocation1DRead = Allocation1DRead;
    mEntryFuncs.Allocation2DData = Allocation2DData;
    mEntryFuncs.Allocation2DRead = Allocation2DRead;
    mEntryFuncs.Allocation3DData = Allocation3DData;
    mEntryFuncs.Allocation3DRead = Allocation3DRead;
    mEntryFuncs.AllocationAdapterCreate = AllocationAdapterCreate;
    mEntryFuncs.AllocationAdapterOffset = AllocationAdapterOffset;
    mEntryFuncs.AllocationCopy2DRange = AllocationCopy2DRange;
    mEntryFuncs.AllocationCopy3DRange = AllocationCopy3DRange;
    mEntryFuncs.AllocationCopyToBitmap = AllocationCopyToBitmap;
    mEntryFuncs.AllocationCreateFromBitmap = AllocationCreateFromBitmap;
    mEntryFuncs.AllocationCreateTyped = AllocationCreateTyped;
    mEntryFuncs.AllocationCubeCreateFromBitmap = AllocationCubeCreateFromBitmap;
    mEntryFuncs.AllocationElementData = AllocationElementData;
    mEntryFuncs.AllocationElementRead = AllocationElementRead;
    mEntryFuncs.AllocationGenerateMipmaps = AllocationGenerateMipmaps;
    mEntryFuncs.AllocationGetPointer = AllocationGetPointer;
    mEntryFuncs.AllocationGetSurface = AllocationGetSurface;
    mEntryFuncs.AllocationGetType = AllocationGetType;
    mEntryFuncs.AllocationIoReceive = AllocationIoReceive;
    mEntryFuncs.AllocationIoSend = AllocationIoSend;
    mEntryFuncs.AllocationRead = AllocationRead;
    mEntryFuncs.AllocationResize1D = AllocationResize1D;
    mEntryFuncs.AllocationSetSurface = AllocationSetSurface;
    mEntryFuncs.AllocationSetupBufferQueue = AllocationSetupBufferQueue;
    mEntryFuncs.AllocationShareBufferQueue = AllocationShareBufferQueue;
    mEntryFuncs.AllocationSyncAll = AllocationSyncAll;
    mEntryFuncs.AssignName = AssignName;
    mEntryFuncs.ClosureCreate = ClosureCreate;
    mEntryFuncs.ClosureSetArg = ClosureSetArg;
    mEntryFuncs.ClosureSetGlobal = ClosureSetGlobal;
    mEntryFuncs.ContextCreate = ContextCreate;
    mEntryFuncs.ContextDeinitToClient = ContextDeinitToClient;
    mEntryFuncs.ContextDestroy = ContextDestroy;
    mEntryFuncs.ContextDump = ContextDump;
    mEntryFuncs.ContextFinish = ContextFinish;
    mEntryFuncs.ContextGetMessage = ContextGetMessage;
    mEntryFuncs.ContextInitToClient = ContextInitToClient;
    mEntryFuncs.ContextPeekMessage = ContextPeekMessage;
    mEntryFuncs.ContextSendMessage = ContextSendMessage;
    mEntryFuncs.ContextSetCacheDir = ContextSetCacheDir;
    mEntryFuncs.ContextSetPriority = ContextSetPriority;
    mEntryFuncs.ElementCreate = ElementCreate;
    mEntryFuncs.ElementCreate2 = ElementCreate2;
    mEntryFuncs.ElementGetNativeData = ElementGetNativeData;
    mEntryFuncs.ElementGetSubElements = ElementGetSubElements;
    mEntryFuncs.GetName = GetName;
    mEntryFuncs.InvokeClosureCreate = InvokeClosureCreate;
    mEntryFuncs.ObjDestroy = ObjDestroy;
    mEntryFuncs.SamplerCreate = SamplerCreate;
    mEntryFuncs.ScriptBindAllocation = ScriptBindAllocation;
    mEntryFuncs.ScriptCCreate = ScriptCCreate;
    mEntryFuncs.ScriptFieldIDCreate = ScriptFieldIDCreate;
    mEntryFuncs.ScriptForEach = ScriptForEach;
    mEntryFuncs.ScriptForEachMulti = ScriptForEachMulti;
    mEntryFuncs.ScriptGetVarV = ScriptGetVarV;
    mEntryFuncs.ScriptGroup2Create = ScriptGroup2Create;
    mEntryFuncs.ScriptGroupCreate = ScriptGroupCreate;
    mEntryFuncs.ScriptGroupExecute = ScriptGroupExecute;
    mEntryFuncs.ScriptGroupSetInput = ScriptGroupSetInput;
    mEntryFuncs.ScriptGroupSetOutput = ScriptGroupSetOutput;
    mEntryFuncs.ScriptIntrinsicCreate = ScriptIntrinsicCreate;
    mEntryFuncs.ScriptInvoke = ScriptInvoke;
    mEntryFuncs.ScriptInvokeIDCreate = ScriptInvokeIDCreate;
    mEntryFuncs.ScriptInvokeV = ScriptInvokeV;
    mEntryFuncs.ScriptKernelIDCreate = ScriptKernelIDCreate;
    mEntryFuncs.ScriptReduce = ScriptReduce;
    mEntryFuncs.ScriptSetTimeZone = ScriptSetTimeZone;
    mEntryFuncs.ScriptSetVarD = ScriptSetVarD;
    mEntryFuncs.ScriptSetVarF = ScriptSetVarF;
    mEntryFuncs.ScriptSetVarI = ScriptSetVarI;
    mEntryFuncs.ScriptSetVarJ = ScriptSetVarJ;
    mEntryFuncs.ScriptSetVarObj = ScriptSetVarObj;
    mEntryFuncs.ScriptSetVarV = ScriptSetVarV;
    mEntryFuncs.ScriptSetVarVE = ScriptSetVarVE;
    mEntryFuncs.TypeCreate = TypeCreate;
    mEntryFuncs.TypeGetNativeData = TypeGetNativeData;
}

void RsHidlAdaptation::InitializeHalDeviceContext()
{
    ALOGD("IRenderScriptDevice::getService()");
    if (getProp("debug.rs.rsov") == 0 &&
        getProp("debug.rs.default-CPU-driver") == 0) {
        // get HIDL service and register callback
        mHidl = IDevice::getService();
    }
    ALOGD("IRenderScriptDevice::getService() returned %p", mHidl.get());

    if (mHidl == NULL) {
        ALOGD("Using Fallback Path.");
        RsFallbackAdaptation& fallbackInstance = RsFallbackAdaptation::GetInstance();
        mEntryFuncs = *(fallbackInstance.GetEntryFuncs());
   } else {
        ALOGD("HIDL successfully loaded.");
        LoadDispatchForHidl();
    }
}

IContext *RsHidlAdaptation::GetIContextHandle(RsContext context) {
    return (IContext *)context;
}

RsContext RsHidlAdaptation::ContextCreate(RsDevice vdev, uint32_t version, uint32_t sdkVersion, RsContextType ct, uint32_t flags)
{
    // Get the handle to IContext interface object and save it to the map.
    sp<IContext> context = mHidl->contextCreate(sdkVersion, (ContextType)ct, flags);
    RsContext ret = (RsContext)(uintptr_t)context.get();

    std::unique_lock<std::mutex> lock(mContextsMutex);
    mContexts.insert(context);
    return ret;
}

void RsHidlAdaptation::ContextDestroy (RsContext context)
{
    // Destroy the driver context and remove IContext handle from the map.
    GetIContextHandle(context)->contextDestroy();

    std::unique_lock<std::mutex> lock(mContextsMutex);
    mContexts.erase((IContext*)context);
}

const void* RsHidlAdaptation::AllocationGetType(RsContext context, RsAllocation allocation)
{
    // TODO: Replace this idiom "(uint64_t)(uintptr_t)" with a rs_to_hal function?
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;
    uint64_t typeRet = GetIContextHandle(context)->allocationGetType(_allocation);
    return (void *)typeRet;
}


void RsHidlAdaptation::TypeGetNativeData(RsContext context, RsType type, uintptr_t *typedata, uint32_t typeDataSize)
{
    uint64_t _type = (uint64_t)(uintptr_t)type;

    GetIContextHandle(context)->typeGetNativeMetadata(_type,
                               [typedata, typeDataSize] (const hidl_vec<uint64_t> &retTypeData){
                                   for (uint32_t i=0; i<typeDataSize; i++) {
                                       typedata[i] = (uintptr_t)retTypeData[i];
                                   }
                               });
}


void RsHidlAdaptation::ElementGetNativeData(RsContext context, RsElement element, uint32_t *elemData, uint32_t elemDataSize)
{
    uint64_t _element = (uint64_t)(uintptr_t)element;

    GetIContextHandle(context)->elementGetNativeMetadata(_element,
                                [elemData, elemDataSize] (const hidl_vec<uint32_t> &retElemData){
                                    for (uint32_t i=0; i<elemDataSize; i++) {
                                        elemData[i] = retElemData[i];
                                    }
                                });
}

void RsHidlAdaptation::ElementGetSubElements(RsContext context, RsElement element, uintptr_t *ids, const char **names, size_t *arraySizes, uint32_t dataSize)
{
    uint64_t _element = (uint64_t)(uintptr_t)element;
    uint64_t _ids = (uint64_t)(uintptr_t)ids;
    uint64_t _names = (uint64_t)(uintptr_t)names;
    uint64_t _arraySizes = (uint64_t)(uintptr_t)arraySizes;

    GetIContextHandle(context)->elementGetSubElements(_element, dataSize,
                                 [ids, names, arraySizes, dataSize] (const hidl_vec<uint64_t> &retIds, const hidl_vec<hidl_string> &retNames, const hidl_vec<Size> &retArraySizes){
                                     for (uint32_t i=0; i<dataSize; i++) {
                                         ids[i] = static_cast<uintptr_t>(retIds[i]);
                                         names[i] = static_cast<const char *>(retNames[i].c_str());
                                         arraySizes[i] = static_cast<size_t>(retArraySizes[i]);
                                     }
                                 });
}


void RsHidlAdaptation::GetName(RsContext context, void * obj, const char **name) {
    uint64_t _obj = (uint64_t)(uintptr_t)obj;

    GetIContextHandle(context)->getName(_obj, [name](hidl_string ret_name) {*name = ret_name.c_str();});
}

RsClosure RsHidlAdaptation::ClosureCreate(RsContext context, RsScriptKernelID kernelID,
                                          RsAllocation returnValue,
                                          RsScriptFieldID* fieldIDs, size_t fieldIDs_length,
                                          int64_t* values, size_t values_length,
                                          int* sizes, size_t sizes_length,
                                          RsClosure* depClosures, size_t depClosures_length,
                                          RsScriptFieldID* depFieldIDs,
                                          size_t depFieldIDs_length)
{
    uint64_t _kernelID = (uint64_t)(uintptr_t)kernelID;
    uint64_t _returnValue = (uint64_t)(uintptr_t)returnValue;

    std::vector<ScriptFieldID> _fieldIDs(fieldIDs_length);
    std::vector<int64_t> _values(values_length);
    std::vector<int32_t> _sizes(sizes_length);
    std::vector<Closure> _depClosures(depClosures_length);
    std::vector<ScriptFieldID> _depFieldIDs(depFieldIDs_length);

    // TODO: Replace this idiom with a rs_to_hal function?
    for (size_t i = 0; i < fieldIDs_length; i++) {
        _fieldIDs[i] = (ScriptFieldID)(uintptr_t)fieldIDs[i];
    }
    for (size_t i = 0; i < values_length; i++) {
        _values[i] = (int64_t)values[i];
    }
    for (size_t i = 0; i < sizes_length; i++) {
        _sizes[i] = (int32_t)sizes[i];
    }
    for (size_t i = 0; i < depClosures_length; i++) {
        _depClosures[i] = (Closure)(uintptr_t)depClosures[i];
    }
    for (size_t i = 0; i < depFieldIDs_length; i++) {
        _depFieldIDs[i] = (ScriptFieldID)(uintptr_t)depFieldIDs[i];
    }

    uint64_t closure = GetIContextHandle(context)->closureCreate(_kernelID, _returnValue,
                                                            _fieldIDs, _values, _sizes,
                                                            _depClosures, _depFieldIDs);
    return (RsClosure) closure;

}

RsClosure RsHidlAdaptation::InvokeClosureCreate(RsContext context, RsScriptInvokeID invokeID,
                                                const void* params, const size_t paramLength,
                                                const RsScriptFieldID* fieldIDs, const size_t fieldIDs_length,
                                                const int64_t* values, const size_t values_length,
                                                const int* sizes, const size_t sizes_length)
{
    uint64_t _invokeID = (uint64_t)(uintptr_t)invokeID;

    hidl_vec<uint8_t> _params;
    _params.setToExternal(reinterpret_cast<uint8_t *>(const_cast<void *>(params)), paramLength);

    std::vector<ScriptFieldID> _fieldIDs(fieldIDs_length);
    std::vector<int64_t> _values(values_length);
    std::vector<int32_t> _sizes(sizes_length);

    for (size_t i = 0; i < fieldIDs_length; i++) {
        _fieldIDs[i] = (ScriptFieldID)(uintptr_t)fieldIDs[i];
    }
    for (size_t i = 0; i < values_length; i++) {
        _values[i] = (int64_t)values[i];
    }
    for (size_t i = 0; i < sizes_length; i++) {
        _sizes[i] = (int32_t)sizes[i];
    }

    uint64_t closure = GetIContextHandle(context)->invokeClosureCreate(_invokeID,
                                                                  _params, _fieldIDs,
                                                                  _values, _sizes);
    return (RsClosure) closure;
}

void RsHidlAdaptation::ClosureSetArg(RsContext context, RsClosure closure, uint32_t index,
                                     uintptr_t value, int size)
{
    uint64_t _closure = (uint64_t)(uintptr_t)closure;
    void * _value = (void *)value;
    GetIContextHandle(context)->closureSetArg(_closure, index, _value, size);
}
void RsHidlAdaptation::ClosureSetGlobal(RsContext context, RsClosure closure,
                                        RsScriptFieldID fieldID, int64_t value,
                                        int size)
{
    uint64_t _closure = (uint64_t)(uintptr_t)closure;
    uint64_t _fieldID = (uint64_t)(uintptr_t)fieldID;
    GetIContextHandle(context)->closureSetGlobal(_closure, _fieldID, value, size);
}

RsMessageToClientType RsHidlAdaptation::ContextGetMessage (RsContext context, void * data, size_t data_length,
                                                           size_t * receiveLen, size_t receiveLen_length,
                                                           uint32_t * subID, size_t subID_length)
{
    RsMessageToClientType msgType;
    GetIContextHandle(context)->contextGetMessage(data, data_length,
        [&msgType, receiveLen](MessageToClientType retMessageType, uint64_t retReceiveLen) {
            msgType = (RsMessageToClientType) retMessageType;
            *receiveLen = retReceiveLen;
        });
    return msgType;
}

RsMessageToClientType RsHidlAdaptation::ContextPeekMessage (RsContext context,
                                                            size_t * receiveLen, size_t receiveLen_length,
                                                            uint32_t * subID, size_t subID_length)
{
    RsMessageToClientType msgType;
    GetIContextHandle(context)->contextPeekMessage(
        [&msgType, receiveLen, subID](MessageToClientType retMessageType, uint64_t retReceiveLen, uint32_t retSubID) {
            msgType = (RsMessageToClientType) retMessageType;
            *receiveLen = retReceiveLen;
            *subID = retSubID;
        });

    return msgType;

}

void RsHidlAdaptation::ContextSendMessage (RsContext context, uint32_t id, const uint8_t *data, size_t len)
{
    hidl_vec<uint8_t> _data;
    _data.setToExternal(const_cast<uint8_t *>(data), len);
    GetIContextHandle(context)->contextSendMessage(id, _data);
}

void RsHidlAdaptation::ContextInitToClient (RsContext context)
{
    GetIContextHandle(context)->contextInitToClient();
}

void RsHidlAdaptation::ContextDeinitToClient (RsContext context)
{
    GetIContextHandle(context)->contextDeinitToClient();
}


RsType RsHidlAdaptation::TypeCreate (RsContext context, RsElement element, uint32_t dimX,
                                     uint32_t dimY, uint32_t dimZ, bool mipmaps,
                                     bool faces, uint32_t yuv)
{
    uint64_t _element = (uint64_t)(uintptr_t)element;

    uint64_t type = GetIContextHandle(context)->typeCreate(_element, dimX, dimY, dimZ, mipmaps, faces,
                                                      (YuvFormat) yuv);
    return (RsType) type;
}

RsAllocation RsHidlAdaptation::AllocationCreateTyped (RsContext context, RsType type,
                                                      RsAllocationMipmapControl mipmaps,
                                                      uint32_t usages, uintptr_t ptr)
{
    uint64_t _type = (uint64_t)(uintptr_t)type;
    void * _ptr = (void *)ptr;

    uint64_t allocation = GetIContextHandle(context)->allocationCreateTyped(_type,
        (AllocationMipmapControl)mipmaps, usages, _ptr);
    return (RsAllocation) allocation;
}


RsAllocation RsHidlAdaptation::AllocationCreateFromBitmap (RsContext context, RsType type,
                                                           RsAllocationMipmapControl mipmaps,
                                                           const void *data, size_t sizeBytes, uint32_t usages)
{
    uint64_t _type = (uint64_t)(uintptr_t)type;

    hidl_vec<uint8_t> _bitmap;
    _bitmap.setToExternal(reinterpret_cast<uint8_t *>(const_cast<void *>(data)), sizeBytes);

    uint64_t allocation = GetIContextHandle(context)->allocationCreateFromBitmap(_type,
        (AllocationMipmapControl)mipmaps, _bitmap, usages);
    return (RsAllocation) allocation;
}

RsAllocation RsHidlAdaptation::AllocationCubeCreateFromBitmap(RsContext context, RsType type,
                                                              RsAllocationMipmapControl mipmaps,
                                                              const void *data, size_t sizeBytes, uint32_t usages)
{
    uint64_t _type = (uint64_t)(uintptr_t)type;

    hidl_vec<uint8_t> _bitmap;
    _bitmap.setToExternal(reinterpret_cast<uint8_t *>(const_cast<void *>(data)), sizeBytes);

    uint64_t allocation = GetIContextHandle(context)->allocationCubeCreateFromBitmap(_type, (AllocationMipmapControl)mipmaps, _bitmap, usages);
    return (RsAllocation) allocation;
}

RsNativeWindow RsHidlAdaptation::AllocationGetSurface (RsContext context, RsAllocation allocation)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    uint64_t window = GetIContextHandle(context)->allocationGetNativeWindow(_allocation);
    return (RsNativeWindow) window;
}
void RsHidlAdaptation::AllocationSetSurface (RsContext context, RsAllocation allocation, RsNativeWindow window)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;
    uint64_t _window = (uint64_t)(uintptr_t)window;

    GetIContextHandle(context)->allocationSetNativeWindow(_allocation, _window);
}

void RsHidlAdaptation::ContextFinish (RsContext context)
{
    GetIContextHandle(context)->contextFinish();
}

void RsHidlAdaptation::ContextDump (RsContext context, int32_t bits)
{
    GetIContextHandle(context)->contextLog();
}

void RsHidlAdaptation::ContextSetPriority (RsContext context, int32_t priority)
{
    GetIContextHandle(context)->contextSetPriority((ThreadPriorities)priority);
}

void RsHidlAdaptation::ContextSetCacheDir (RsContext context, const char *cacheDir, size_t cacheDir_length)
{
    GetIContextHandle(context)->contextSetCacheDir(hidl_string(cacheDir));
}

void RsHidlAdaptation::AssignName (RsContext context, RsObjectBase obj, const char* name, size_t size)
{
    uint64_t _obj = (uint64_t)(uintptr_t)obj;

    GetIContextHandle(context)->assignName(_obj, hidl_string(name));
}

void RsHidlAdaptation::ObjDestroy (RsContext context, RsAsyncVoidPtr obj)
{
    uint64_t _obj = (uint64_t)(uintptr_t)obj;

    GetIContextHandle(context)->objDestroy(_obj);
}


RsElement RsHidlAdaptation::ElementCreate (RsContext context,
                                           RsDataType dt,
                                           RsDataKind dk,
                                           bool norm,
                                           uint32_t vecSize)
{
    uint64_t element = GetIContextHandle(context)->elementCreate((DataType) dt,
                                                            (DataKind) dk,
                                                            norm,
                                                            vecSize);
    return (RsElement) element;
}

RsElement RsHidlAdaptation::ElementCreate2 (RsContext context,
                                            const RsElement * ein,
                                            size_t ein_length,
                                            const char ** names,
                                            size_t nameLengths_length,
                                            const size_t * nameLengths,
                                            const uint32_t * arraySizes,
                                            size_t arraySizes_length)
{
    std::vector<uint64_t> _ein(ein_length);
    std::vector<hidl_string> _names(nameLengths_length);
    std::vector<Size> _arraySizes(arraySizes_length);

    for (size_t i = 0; i < ein_length; i++) {
        _ein[i] = (uint64_t)((uintptr_t)ein[i]);
    }
    for (size_t i = 0; i < ein_length; i++) {
        _names[i] = hidl_string(names[i]);
    }
    for (size_t i = 0; i < arraySizes_length; i++) {
        _arraySizes[i] = (Size)arraySizes[i];
    }

    uint64_t element = GetIContextHandle(context)->elementComplexCreate(_ein, _names, _arraySizes);
    return (RsElement) element;
}

void RsHidlAdaptation::AllocationCopyToBitmap (RsContext context, RsAllocation allocation, void *data, size_t sizeBytes)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->allocationCopyToBitmap(_allocation, data, sizeBytes);
}

void RsHidlAdaptation::Allocation1DData (RsContext context, RsAllocation allocation, uint32_t xoff, uint32_t lod,
                                         uint32_t count, const void *data, size_t sizeBytes)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    hidl_vec<uint8_t> _data;
    _data.setToExternal(reinterpret_cast<uint8_t *>(const_cast<void *>(data)), sizeBytes);

    GetIContextHandle(context)->allocation1DWrite(_allocation, xoff, lod, count, _data);
}
void RsHidlAdaptation::Allocation1DElementData (RsContext context, RsAllocation allocation, uint32_t xoff,
                                                uint32_t lod, const void *data, size_t sizeBytes, size_t eoff)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    hidl_vec<uint8_t> _data;
    _data.setToExternal(reinterpret_cast<uint8_t *>(const_cast<void *>(data)), sizeBytes);

    GetIContextHandle(context)->allocationElementWrite(_allocation, xoff, 0, 0, lod, _data, eoff);
}

void RsHidlAdaptation::AllocationElementData (RsContext context, RsAllocation allocation, uint32_t x, uint32_t y, uint32_t z,
                                              uint32_t lod, const void *data, size_t sizeBytes, size_t eoff)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    hidl_vec<uint8_t> _data;
    _data.setToExternal(reinterpret_cast<uint8_t *>(const_cast<void *>(data)), sizeBytes);

    GetIContextHandle(context)->allocationElementWrite(_allocation, x, y, z, lod, _data, eoff);
}

void RsHidlAdaptation::Allocation2DData (RsContext context, RsAllocation allocation, uint32_t xoff, uint32_t yoff,
                                         uint32_t lod, RsAllocationCubemapFace face,
                                         uint32_t w, uint32_t h, const void *data, size_t sizeBytes, size_t stride)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    hidl_vec<uint8_t> _data;
    _data.setToExternal(reinterpret_cast<uint8_t *>(const_cast<void *>(data)), sizeBytes);

    GetIContextHandle(context)->allocation2DWrite(_allocation, xoff, yoff, lod, (AllocationCubemapFace)face, w, h, _data, stride);
}

void RsHidlAdaptation::Allocation3DData (RsContext context, RsAllocation allocation, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod,
                                         uint32_t w, uint32_t h, uint32_t d, const void *data, size_t sizeBytes, size_t stride)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    hidl_vec<uint8_t> _data;
    _data.setToExternal(reinterpret_cast<uint8_t *>(const_cast<void *>(data)), sizeBytes);

    GetIContextHandle(context)->allocation3DWrite(_allocation, xoff, yoff, zoff, lod, w, h, d, _data, stride);
}

void RsHidlAdaptation::AllocationGenerateMipmaps (RsContext context, RsAllocation allocation)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->allocationGenerateMipmaps(_allocation);
}

void RsHidlAdaptation::AllocationRead (RsContext context, RsAllocation allocation, void *data, size_t sizeBytes)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->allocationRead(_allocation, data, sizeBytes);
}

void RsHidlAdaptation::Allocation1DRead (RsContext context, RsAllocation allocation, uint32_t xoff, uint32_t lod,
                                         uint32_t count, void *data, size_t sizeBytes)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->allocation1DRead(_allocation, xoff, lod, count, data, sizeBytes);
}

void RsHidlAdaptation::AllocationElementRead (RsContext context, RsAllocation allocation, uint32_t x, uint32_t y, uint32_t z,
                                              uint32_t lod, void *data, size_t sizeBytes, size_t eoff)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->allocationElementRead(_allocation, x, y, z, lod, data, sizeBytes, eoff);
}

void RsHidlAdaptation::Allocation2DRead (RsContext context, RsAllocation allocation, uint32_t xoff, uint32_t yoff,
                                         uint32_t lod, RsAllocationCubemapFace face,
                                         uint32_t w, uint32_t h, void *data, size_t sizeBytes, size_t stride)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->allocation2DRead(_allocation, xoff, yoff, lod, (AllocationCubemapFace)face, w, h, data, sizeBytes, stride);
}

void RsHidlAdaptation::Allocation3DRead (RsContext context, RsAllocation allocation, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod,
                                         uint32_t w, uint32_t h, uint32_t d, void *data, size_t sizeBytes, size_t stride)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->allocation3DRead(_allocation, xoff, yoff, zoff, lod, w, h, d, data, sizeBytes, stride);
}

void RsHidlAdaptation::AllocationSyncAll (RsContext context, RsAllocation allocation, RsAllocationUsageType usage)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->allocationSyncAll(_allocation,
        (AllocationUsageType) usage);
}

void RsHidlAdaptation::AllocationResize1D (RsContext context, RsAllocation allocation, uint32_t dimX)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->allocationResize1D(_allocation, dimX);
}

void RsHidlAdaptation::AllocationCopy2DRange (RsContext context,
                                              RsAllocation dstAlloc,
                                              uint32_t dstXoff, uint32_t dstYoff,
                                              uint32_t dstMip, uint32_t dstFace,
                                              uint32_t width, uint32_t height,
                                              RsAllocation srcAlloc,
                                              uint32_t srcXoff, uint32_t srcYoff,
                                              uint32_t srcMip, uint32_t srcFace)
{
    uint64_t _dstAlloc = (uint64_t)(uintptr_t)dstAlloc;
    uint64_t _srcAlloc = (uint64_t)(uintptr_t)srcAlloc;

    GetIContextHandle(context)->allocationCopy2DRange(_dstAlloc, dstXoff, dstYoff, dstMip, (AllocationCubemapFace)dstFace, width, height,
                                 _srcAlloc, srcXoff, srcYoff, srcMip, (AllocationCubemapFace)srcFace);
}
void RsHidlAdaptation::AllocationCopy3DRange (RsContext context,
                                              RsAllocation dstAlloc,
                                              uint32_t dstXoff, uint32_t dstYoff, uint32_t dstZoff,
                                              uint32_t dstMip,
                                              uint32_t width, uint32_t height, uint32_t depth,
                                              RsAllocation srcAlloc,
                                              uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff,
                                              uint32_t srcMip)
{
    uint64_t _dstAlloc = (uint64_t)(uintptr_t)dstAlloc;
    uint64_t _srcAlloc = (uint64_t)(uintptr_t)srcAlloc;

    GetIContextHandle(context)->allocationCopy3DRange(_dstAlloc, dstXoff, dstYoff, dstZoff, dstMip, width, height, depth,
                                                 _srcAlloc, srcXoff, srcYoff, srcZoff, srcMip);
}

RsSampler RsHidlAdaptation::SamplerCreate (RsContext context,
                                           RsSamplerValue magFilter,
                                           RsSamplerValue minFilter,
                                           RsSamplerValue wrapS,
                                           RsSamplerValue wrapT,
                                           RsSamplerValue wrapR,
                                           float aniso)
{
    uint64_t sampler = GetIContextHandle(context)->samplerCreate((SamplerValue) magFilter,
                                                            (SamplerValue)minFilter,
                                                            (SamplerValue)wrapS,
                                                            (SamplerValue)wrapT,
                                                            (SamplerValue)wrapR,
                                                            aniso);
    return (RsSampler) sampler;
}

void RsHidlAdaptation::ScriptBindAllocation (RsContext context, RsScript script, RsAllocation allocation, uint32_t slot)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->scriptBindAllocation(_script, _allocation, slot);
}

void RsHidlAdaptation::ScriptSetTimeZone (RsContext context, RsScript script, const char* timezone, size_t size)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    GetIContextHandle(context)->scriptSetTimeZone(_script, hidl_string(timezone));
}

void RsHidlAdaptation::ScriptInvoke (RsContext context, RsScript script, uint32_t slot)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    GetIContextHandle(context)->scriptInvoke(_script, slot);
}

void RsHidlAdaptation::ScriptInvokeV (RsContext context, RsScript script, uint32_t slot, const void *data, size_t len)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;
    hidl_vec<uint8_t> _data;
    _data.setToExternal(reinterpret_cast<uint8_t *>(const_cast<void *>(data)), len);

    GetIContextHandle(context)->scriptInvokeV(_script, slot, _data);
}

void RsHidlAdaptation::ScriptForEach (RsContext context, RsScript script, uint32_t slot,
                                      RsAllocation vain, RsAllocation vaout,
                                      const void *params, size_t paramLen,
                                      const RsScriptCall *sc, size_t scLen)
{
    RsAllocation * vains = nullptr;
    size_t inLen = 0;
    if (vain) {
        vains = &vain;
        inLen = 1;
    }
    ScriptForEachMulti(context, script, slot, vains, inLen, vaout, params, paramLen, sc, scLen);
}

void RsHidlAdaptation::ScriptForEachMulti (RsContext context, RsScript script, uint32_t slot,
                                           RsAllocation *vains, size_t inLen,
                                           RsAllocation vaout, const void *params,
                                           size_t paramLen, const RsScriptCall *sc,
                                           size_t scLen)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    std::vector<Allocation> _vains(inLen);
    for (size_t i = 0; i < inLen; i++) {
        _vains[i] = (Allocation)(uintptr_t)vains[i];
    }

    uint64_t _vaout = (uint64_t)(uintptr_t)vaout;

    hidl_vec<uint8_t> _params;
    _params.setToExternal(reinterpret_cast<uint8_t *>(const_cast<void *>(params)), paramLen);

    ScriptCall * _scPtr = nullptr;
    ScriptCall _sc;
    if (sc) {
        _sc.strategy    = static_cast<ForEachStrategy>(sc->strategy);
        _sc.xStart      = sc->xStart;
        _sc.xEnd        = sc->xEnd;
        _sc.yStart      = sc->yStart;
        _sc.yEnd        = sc->yEnd;
        _sc.zStart      = sc->zStart;
        _sc.zEnd        = sc->zEnd;
        _sc.arrayStart  = sc->arrayStart;
        _sc.arrayEnd    = sc->arrayEnd;
        _sc.array2Start = sc->array2Start;
        _sc.array2End   = sc->arrayEnd;
        _sc.array3Start = sc->array3Start;
        _sc.array3End   = sc->arrayEnd;
        _sc.array4Start = sc->array4Start;
        _sc.array4End   = sc->arrayEnd;

        _scPtr = &_sc;
    }
    GetIContextHandle(context)->scriptForEach(_script, slot, _vains, _vaout, _params, _scPtr);
}

void RsHidlAdaptation::ScriptReduce (RsContext context, RsScript script, uint32_t slot,
                                     RsAllocation *vains, size_t inLen, RsAllocation vaout,
                                     const RsScriptCall *sc, size_t scLen)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    std::vector<Allocation> _vains(inLen);
    for (size_t i = 0; i < inLen; i++) {
        _vains[i] = (Allocation)(uintptr_t)vains[i];
    }

    uint64_t _vaout = (uint64_t)(uintptr_t)vaout;

    ScriptCall * _scPtr = nullptr;
    ScriptCall _sc;
    if (sc) {
        _sc.strategy    = static_cast<ForEachStrategy>(sc->strategy);
        _sc.xStart      = sc->xStart;
        _sc.xEnd        = sc->xEnd;
        _sc.yStart      = sc->yStart;
        _sc.yEnd        = sc->yEnd;
        _sc.zStart      = sc->zStart;
        _sc.zEnd        = sc->zEnd;
        _sc.arrayStart  = sc->arrayStart;
        _sc.arrayEnd    = sc->arrayEnd;
        _sc.array2Start = sc->array2Start;
        _sc.array2End   = sc->arrayEnd;
        _sc.array3Start = sc->array3Start;
        _sc.array3End   = sc->arrayEnd;
        _sc.array4Start = sc->array4Start;
        _sc.array4End   = sc->arrayEnd;

        _scPtr = &_sc;
    }
    GetIContextHandle(context)->scriptReduce(_script, slot, _vains, _vaout, _scPtr);
}

void RsHidlAdaptation::ScriptSetVarI (RsContext context, RsScript script, uint32_t slot, int value)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    GetIContextHandle(context)->scriptSetVarI(_script, slot, value);
}

void RsHidlAdaptation::ScriptSetVarObj (RsContext context, RsScript script, uint32_t slot, RsObjectBase obj)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;
    uint64_t _obj = (uint64_t)(uintptr_t)obj;

    GetIContextHandle(context)->scriptSetVarObj(_script, slot, _obj);
}

void RsHidlAdaptation::ScriptSetVarJ (RsContext context, RsScript script, uint32_t slot, int64_t value)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    GetIContextHandle(context)->scriptSetVarJ(_script, slot, value);
}

void RsHidlAdaptation::ScriptSetVarF (RsContext context, RsScript script, uint32_t slot, float value)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    GetIContextHandle(context)->scriptSetVarF(_script, slot, value);
}

void RsHidlAdaptation::ScriptSetVarD (RsContext context, RsScript script, uint32_t slot, double value)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    GetIContextHandle(context)->scriptSetVarD(_script, slot, value);
}

void RsHidlAdaptation::ScriptSetVarV (RsContext context, RsScript script, uint32_t slot, const void* data, size_t len)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;
    hidl_vec<uint8_t> _data;
    _data.setToExternal(reinterpret_cast<uint8_t *>(const_cast<void *>(data)), len);

    GetIContextHandle(context)->scriptSetVarV(_script, slot, _data);
}

void RsHidlAdaptation::ScriptGetVarV (RsContext context, RsScript script, uint32_t slot, void* data, size_t len)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    GetIContextHandle(context)->scriptGetVarV(_script, slot, len,
                         [data, len] (const hidl_vec<uint8_t> &retData) {
                             memcpy(data, retData.data(), len);
                         });
}

void RsHidlAdaptation::ScriptSetVarVE (RsContext context, RsScript script, uint32_t slot,
                                       const void *data, size_t len, RsElement ve,
                                       const uint32_t *dims, size_t dimLen)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    hidl_vec<uint8_t> _data;
    _data.setToExternal(reinterpret_cast<uint8_t *>(const_cast<void *>(data)), len);

    uint64_t _ve = (uint64_t)(uintptr_t)ve;

    hidl_vec<uint32_t> _dims;
    _dims.setToExternal(const_cast<uint32_t *>(dims), dimLen / sizeof(uint32_t));

    GetIContextHandle(context)->scriptSetVarVE(_script, slot, _data, _ve, _dims);
}

RsScript RsHidlAdaptation::ScriptCCreate (RsContext context,
                                          const char *resName, size_t resName_length,
                                          const char *cacheDir, size_t cacheDir_length,
                                          const char *text, size_t text_length)
{
    hidl_vec<uint8_t> _text;
    _text.setToExternal(reinterpret_cast<uint8_t *>(const_cast<char *>(text)), text_length);
    uint64_t scriptc = GetIContextHandle(context)->scriptCCreate(hidl_string(resName), hidl_string(cacheDir), _text);
    return (RsScript) scriptc;
}

RsScript RsHidlAdaptation::ScriptIntrinsicCreate (RsContext context, uint32_t id, RsElement element)
{
    uint64_t _element = (uint64_t)(uintptr_t)element;

    uint64_t intrinsic = GetIContextHandle(context)->scriptIntrinsicCreate((ScriptIntrinsicID)id, _element);
    return (RsScript) intrinsic;
}

RsScriptKernelID RsHidlAdaptation::ScriptKernelIDCreate (RsContext context, RsScript script, int slot, int sig)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    uint64_t kernelID = GetIContextHandle(context)->scriptKernelIDCreate(_script, slot, sig);
    return (RsScriptKernelID) kernelID;
}

RsScriptInvokeID RsHidlAdaptation::ScriptInvokeIDCreate (RsContext context, RsScript script, int slot)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    uint64_t invokeID = GetIContextHandle(context)->scriptInvokeIDCreate(_script, slot);
    return (RsScriptInvokeID) invokeID;
}

RsScriptFieldID RsHidlAdaptation::ScriptFieldIDCreate (RsContext context, RsScript script, int slot)
{
    uint64_t _script = (uint64_t)(uintptr_t)script;

    uint64_t fieldID = GetIContextHandle(context)->scriptFieldIDCreate(_script, slot);
    return (RsScriptFieldID) fieldID;
}

RsScriptGroup RsHidlAdaptation::ScriptGroupCreate (RsContext context, RsScriptKernelID * kernels, size_t kernelsSize,
                                                   RsScriptKernelID * src, size_t srcSize,
                                                   RsScriptKernelID * dstK, size_t dstKSize,
                                                   RsScriptFieldID * dstF, size_t dstFSize,
                                                   const RsType * type, size_t typeSize)
{
    std::vector<ScriptKernelID> _kernels(kernelsSize / sizeof(RsScriptKernelID));
    std::vector<ScriptKernelID> _src(srcSize / sizeof(RsScriptKernelID));
    std::vector<ScriptKernelID> _dstK(dstKSize / sizeof(RsScriptKernelID));
    std::vector<ScriptFieldID> _dstF(dstFSize / sizeof(RsScriptFieldID));
    std::vector<Type> _type(typeSize / sizeof(RsType));

    for (size_t i = 0; i < _kernels.size(); i++) {
        _kernels[i] = (ScriptKernelID)(uintptr_t)kernels[i];
    }
    for (size_t i = 0; i < _src.size(); i++) {
        _src[i] = (ScriptKernelID)(uintptr_t)src[i];
    }
    for (size_t i = 0; i < _dstK.size(); i++) {
        _dstK[i] = (ScriptKernelID)(uintptr_t)dstK[i];
    }
    for (size_t i = 0; i < _dstF.size(); i++) {
        _dstF[i] = (ScriptFieldID)(uintptr_t)dstF[i];
    }
    for (size_t i = 0; i < _type.size(); i++) {
        _type[i] = (Type)(uintptr_t)type[i];
    }

    uint64_t scriptGroup = GetIContextHandle(context)->scriptGroupCreate(_kernels, _src, _dstK, _dstF, _type);
    return (RsScriptGroup) scriptGroup;
}

RsScriptGroup2 RsHidlAdaptation::ScriptGroup2Create(RsContext context, const char* name, size_t nameLength,
                                                    const char* cacheDir, size_t cacheDirLength,
                                                    RsClosure* closures, size_t numClosures)
{
    std::vector<Closure> _closures(numClosures);
    for (size_t i = 0; i < numClosures; i++) {
        _closures[i] = (Closure)(uintptr_t)closures[i];
    }

    uint64_t scriptGroup2 = GetIContextHandle(context)->scriptGroup2Create(hidl_string(name), hidl_string(cacheDir), _closures);
    return (RsScriptGroup2) scriptGroup2;
}

void RsHidlAdaptation::ScriptGroupSetOutput (RsContext context, RsScriptGroup sg, RsScriptKernelID kid, RsAllocation alloc)
{
    uint64_t _sg = (uint64_t)(uintptr_t)sg;
    uint64_t _kid = (uint64_t)(uintptr_t)kid;
    uint64_t _alloc = (uint64_t)(uintptr_t)alloc;

    GetIContextHandle(context)->scriptGroupSetOutput(_sg, _kid, _alloc);
}

void RsHidlAdaptation::ScriptGroupSetInput (RsContext context, RsScriptGroup sg, RsScriptKernelID kid, RsAllocation alloc)
{
    uint64_t _sg = (uint64_t)(uintptr_t)sg;
    uint64_t _kid = (uint64_t)(uintptr_t)kid;
    uint64_t _alloc = (uint64_t)(uintptr_t)alloc;

    GetIContextHandle(context)->scriptGroupSetInput(_sg, _kid, _alloc);
}

void RsHidlAdaptation::ScriptGroupExecute (RsContext context, RsScriptGroup sg)
{
    uint64_t _sg = (uint64_t)(uintptr_t)sg;

    GetIContextHandle(context)->scriptGroupExecute(_sg);
}

void RsHidlAdaptation::AllocationIoSend (RsContext context, RsAllocation allocation)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->allocationIoSend(_allocation);
}
int64_t RsHidlAdaptation::AllocationIoReceive (RsContext context, RsAllocation allocation)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->allocationIoReceive(_allocation);
    // Fix me.
    return 0;
}

void * RsHidlAdaptation::AllocationGetPointer (RsContext context, RsAllocation allocation,
                                               uint32_t lod, RsAllocationCubemapFace face,
                                               uint32_t z, uint32_t array, size_t *stride, size_t strideLen)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    void* ptr;
    GetIContextHandle(context)->allocationGetPointer(_allocation, lod,
                                                (AllocationCubemapFace)face, z,
                                                [&ptr, stride] (void* retPtr, uint64_t retStride) {
                                                    ptr = retPtr;
                                                    if (retStride > 0) {
                                                        *stride = retStride;
                                                    }
                                                });
    return ptr;
}

void RsHidlAdaptation::AllocationSetupBufferQueue (RsContext context, RsAllocation allocation, uint32_t numAlloc)
{
    uint64_t _allocation = (uint64_t)(uintptr_t)allocation;

    GetIContextHandle(context)->allocationSetupBufferQueue(_allocation, numAlloc);
}

void RsHidlAdaptation::AllocationShareBufferQueue(RsContext context, RsAllocation valloc1, RsAllocation valloc2)
{
    uint64_t _valloc1 = (uint64_t)(uintptr_t)valloc1;
    uint64_t _valloc2 = (uint64_t)(uintptr_t)valloc2;

    GetIContextHandle(context)->allocationShareBufferQueue(_valloc1, _valloc2);
}

RsAllocation RsHidlAdaptation::AllocationAdapterCreate (RsContext context, RsType vtype, RsAllocation baseAlloc)
{
    uint64_t _vtype = (uint64_t)(uintptr_t)vtype;
    uint64_t _baseAlloc = (uint64_t)(uintptr_t)baseAlloc;

    uint64_t allocationAdapter = GetIContextHandle(context)->allocationAdapterCreate(_vtype, _baseAlloc);
    return (RsAllocation) allocationAdapter;
}

void RsHidlAdaptation::AllocationAdapterOffset (RsContext context, RsAllocation alloc, const uint32_t * offsets, size_t offsets_length)
{
    uint64_t _alloc = (uint64_t)(uintptr_t)alloc;

    hidl_vec<uint32_t> _offsets;
    _offsets.setToExternal(const_cast<uint32_t *>(offsets), offsets_length / sizeof(uint32_t));

    GetIContextHandle(context)->allocationAdapterOffset(_alloc, _offsets);
}