| /* |
| * 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); |
| } |
