RenderScript HIDL client-side implementation
- Client-side implementation converts RenderScript HAL (top level)
from C/C++ to HIDL
- Fallback to default CPU implementation if it could not find a
matching RS driver through HIDL.
- HIDL adaptation and Graphics fallback are handled by two
corresponding singleton classes.
- Remove HOST_STATIC version of libRS from the makefile. The host
version of libRS is not used at all, and generating build errors with
HIDL.
- Always use fallback path for RS graphics API.
- Removed reference to Device from rsContext.cpp. In our current
implementation, Device is equivalent to HIDL IDevice class.
Thus, our HIDL HAL no longer provides DeviceCreate and DeviceDestroy,
making Device no longer useful to Context.
- Wait for the debugger to attach if RS_CONTEXT_WAIT_FOR_ATTACH flag
is set. The waiting part is now moved out of the context class.
Bug: 34396220
Test: mm, all CTS tests pass on bullhead, LiveWallpaper apps using RS
graphics APIs run well.
Merged-In: I86493b11328d5d8c904cebafa99243e92dfdf6a7
Change-Id: I86493b11328d5d8c904cebafa99243e92dfdf6a7
diff --git a/rsHidlAdaptation.cpp b/rsHidlAdaptation.cpp
new file mode 100644
index 0000000..2960de1
--- /dev/null
+++ b/rsHidlAdaptation.cpp
@@ -0,0 +1,1097 @@
+/*
+ * 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.
+ */
+
+#include "cpp/rsDispatch.h"
+#include "rsHidlAdaptation.h"
+#include "rsFallbackAdaptation.h"
+
+#include <cutils/properties.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;
+
+#undef LOG_TAG
+#define LOG_TAG "RenderScript HIDL Adaptation"
+
+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), len);
+
+ 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)
+{
+ ALOGD("resName: %s, cacheDir: %s, text: %s", resName, cacheDir, text);
+
+ 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);
+ std::vector<ScriptKernelID> _src(srcSize);
+ std::vector<ScriptKernelID> _dstK(dstKSize);
+ std::vector<ScriptFieldID> _dstF(dstFSize);
+ std::vector<Type> _type(typeSize);
+
+ for (size_t i = 0; i < kernelsSize; i++) {
+ _kernels[i] = (ScriptKernelID)(uintptr_t)kernels[i];
+ }
+ for (size_t i = 0; i < srcSize; i++) {
+ _src[i] = (ScriptKernelID)(uintptr_t)src[i];
+ }
+ for (size_t i = 0; i < dstKSize; i++) {
+ _dstK[i] = (ScriptKernelID)(uintptr_t)dstK[i];
+ }
+ for (size_t i = 0; i < dstFSize; i++) {
+ _dstF[i] = (ScriptKernelID)(uintptr_t)dstF[i];
+ }
+ for (size_t i = 0; i < typeSize; i++) {
+ _type[i] = (ScriptKernelID)(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);
+
+ GetIContextHandle(context)->allocationAdapterOffset(_alloc, _offsets);
+}
