#define LOG_TAG "android.hardware.renderscript@1.0-impl" #include "Context.h" #include "Device.h" namespace android { namespace hardware { namespace renderscript { namespace V1_0 { namespace implementation { Context::Context(uint32_t sdkVersion, ContextType ct, int32_t flags) { RsDevice _dev = nullptr; uint32_t _version = 0; uint32_t _sdkVersion = sdkVersion; RsContextType _ct = static_cast(ct); int32_t _flags = flags; const char* driverName = nullptr; #ifdef OVERRIDE_RS_DRIVER #define XSTR(S) #S #define STR(S) XSTR(S) #define OVERRIDE_RS_DRIVER_STRING STR(OVERRIDE_RS_DRIVER) static std::string driverString(OVERRIDE_RS_DRIVER_STRING); driverName = driverString.c_str(); #undef XSTR #undef STR #endif // OVERRIDE_RS_DRIVER mContext = Device::getHal().ContextCreateVendor(_dev, _version, _sdkVersion, _ct, _flags, driverName); } // Helper functions template static ReturnType hidl_to_rs(OpaqueHandle src) { return reinterpret_cast(static_cast(src)); } template static ReturnType hidl_to_rs(SourceType* src) { return reinterpret_cast(src); } template static std::vector hidl_to_rs(const hidl_vec& src, Operation operation) { std::vector dst(src.size()); std::transform(src.begin(), src.end(), dst.begin(), operation); return dst; } template static ReturnType rs_to_hidl(SourceType* src) { return static_cast(reinterpret_cast(src)); } template static hidl_vec rs_to_hidl(const std::vector& src, Operation operation) { std::vector dst(src.size()); std::transform(src.begin(), src.end(), dst.begin(), operation); return dst; } // Methods from ::android::hardware::renderscript::V1_0::IContext follow. Return Context::allocationAdapterCreate(Type type, Allocation baseAlloc) { RsType _type = hidl_to_rs(type); RsAllocation _baseAlloc = hidl_to_rs(baseAlloc); RsAllocation _subAlloc = Device::getHal().AllocationAdapterCreate(mContext, _type, _baseAlloc); return rs_to_hidl(_subAlloc); } Return Context::allocationAdapterOffset(Allocation alloc, const hidl_vec& offsets) { RsAllocation _alloc = hidl_to_rs(alloc); const hidl_vec& _offsets = offsets; Device::getHal().AllocationAdapterOffset(mContext, _alloc, _offsets.data(), _offsets.size() * sizeof(uint32_t)); return Void(); } Return Context::allocationGetType(Allocation allocation) { RsAllocation _allocation = hidl_to_rs(allocation); const void* _type = Device::getHal().AllocationGetType(mContext, _allocation); return rs_to_hidl(_type); } Return Context::allocationCreateTyped(Type type, AllocationMipmapControl amips, int32_t usage, Ptr ptr) { RsType _type = hidl_to_rs(type); RsAllocationMipmapControl _amips = static_cast(amips); uint32_t _usage = usage; uintptr_t _ptr = hidl_to_rs(ptr); RsAllocation _allocation = Device::getHal().AllocationCreateTyped(mContext, _type, _amips, _usage, _ptr); return rs_to_hidl(_allocation); } Return Context::allocationCreateFromBitmap(Type type, AllocationMipmapControl amips, const hidl_vec& bitmap, int32_t usage) { RsType _type = hidl_to_rs(type); RsAllocationMipmapControl _amips = static_cast(amips); const hidl_vec& _bitmap = bitmap; uint32_t _usage = usage; RsAllocation _allocation = Device::getHal().AllocationCreateFromBitmap(mContext, _type, _amips, _bitmap.data(), _bitmap.size(), _usage); return rs_to_hidl(_allocation); } Return Context::allocationCubeCreateFromBitmap(Type type, AllocationMipmapControl amips, const hidl_vec& bitmap, int32_t usage) { RsType _type = hidl_to_rs(type); RsAllocationMipmapControl _amips = static_cast(amips); const hidl_vec& _bitmap = bitmap; uint32_t _usage = usage; RsAllocation _allocation = Device::getHal().AllocationCubeCreateFromBitmap(mContext, _type, _amips, _bitmap.data(), _bitmap.size(), _usage); return rs_to_hidl(_allocation); } Return Context::allocationGetNativeWindow(Allocation allocation) { RsAllocation _allocation = hidl_to_rs(allocation); RsNativeWindow _nativeWindow = Device::getHal().AllocationGetSurface(mContext, _allocation); return rs_to_hidl(_nativeWindow); } Return Context::allocationSetNativeWindow(Allocation allocation, NativeWindow nativewindow) { RsAllocation _allocation = hidl_to_rs(allocation); RsNativeWindow _nativewindow = hidl_to_rs(nativewindow); Device::getHal().AllocationSetSurface(mContext, _allocation, _nativewindow); return Void(); } Return Context::allocationSetupBufferQueue(Allocation alloc, uint32_t numBuffer) { RsAllocation _alloc = hidl_to_rs(alloc); uint32_t _numBuffer = numBuffer; Device::getHal().AllocationSetupBufferQueue(mContext, _alloc, _numBuffer); return Void(); } Return Context::allocationShareBufferQueue(Allocation baseAlloc, Allocation subAlloc) { RsAllocation _baseAlloc = hidl_to_rs(baseAlloc); RsAllocation _subAlloc = hidl_to_rs(subAlloc); Device::getHal().AllocationShareBufferQueue(mContext, _baseAlloc, _subAlloc); return Void(); } Return Context::allocationCopyToBitmap(Allocation allocation, Ptr data, Size sizeBytes) { RsAllocation _allocation = hidl_to_rs(allocation); void* _data = hidl_to_rs(data); size_t _sizeBytes = static_cast(sizeBytes); Device::getHal().AllocationCopyToBitmap(mContext, _allocation, _data, _sizeBytes); return Void(); } Return Context::allocation1DWrite(Allocation allocation, uint32_t offset, uint32_t lod, uint32_t count, const hidl_vec& data) { RsAllocation _allocation = hidl_to_rs(allocation); uint32_t _offset = offset; uint32_t _lod = lod; uint32_t _count = count; const void* _dataPtr = hidl_to_rs(data.data()); size_t _sizeBytes = data.size(); Device::getHal().Allocation1DData(mContext, _allocation, _offset, _lod, _count, _dataPtr, _sizeBytes); return Void(); } Return Context::allocationElementWrite(Allocation allocation, uint32_t x, uint32_t y, uint32_t z, uint32_t lod, const hidl_vec& data, Size compIdx) { RsAllocation _allocation = hidl_to_rs(allocation); uint32_t _x = x; uint32_t _y = y; uint32_t _z = z; uint32_t _lod = lod; const void* _dataPtr = hidl_to_rs(data.data()); size_t _sizeBytes = data.size(); size_t _compIdx = static_cast(compIdx); Device::getHal().AllocationElementData(mContext, _allocation, _x, _y, _z, _lod, _dataPtr, _sizeBytes, _compIdx); return Void(); } Return Context::allocation2DWrite(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t lod, AllocationCubemapFace face, uint32_t w, uint32_t h, const hidl_vec& data, Size stride) { RsAllocation _allocation = hidl_to_rs(allocation); uint32_t _xoff = xoff; uint32_t _yoff = yoff; uint32_t _lod = lod; RsAllocationCubemapFace _face = static_cast(face); uint32_t _w = w; uint32_t _h = h; const void* _dataPtr = hidl_to_rs(data.data()); size_t _sizeBytes = data.size(); size_t _stride = static_cast(stride); Device::getHal().Allocation2DData(mContext, _allocation, _xoff, _yoff, _lod, _face, _w, _h, _dataPtr, _sizeBytes, _stride); return Void(); } Return Context::allocation3DWrite(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod, uint32_t w, uint32_t h, uint32_t d, const hidl_vec& data, Size stride) { RsAllocation _allocation = hidl_to_rs(allocation); uint32_t _xoff = xoff; uint32_t _yoff = yoff; uint32_t _zoff = zoff; uint32_t _lod = lod; uint32_t _w = w; uint32_t _h = h; uint32_t _d = d; const void* _dataPtr = hidl_to_rs(data.data()); size_t _sizeBytes = data.size(); size_t _stride = static_cast(stride); Device::getHal().Allocation3DData(mContext, _allocation, _xoff, _yoff, _zoff, _lod, _w, _h, _d, _dataPtr, _sizeBytes, _stride); return Void(); } Return Context::allocationGenerateMipmaps(Allocation allocation) { RsAllocation _allocation = hidl_to_rs(allocation); Device::getHal().AllocationGenerateMipmaps(mContext, _allocation); return Void(); } Return Context::allocationRead(Allocation allocation, Ptr data, Size sizeBytes) { RsAllocation _allocation = hidl_to_rs(allocation); void* _data = hidl_to_rs(data); size_t _sizeBytes = static_cast(sizeBytes); Device::getHal().AllocationRead(mContext, _allocation, _data, _sizeBytes); return Void(); } Return Context::allocation1DRead(Allocation allocation, uint32_t xoff, uint32_t lod, uint32_t count, Ptr data, Size sizeBytes) { RsAllocation _allocation = hidl_to_rs(allocation); uint32_t _xoff = xoff; uint32_t _lod = lod; uint32_t _count = count; void* _data = hidl_to_rs(data); size_t _sizeBytes = static_cast(sizeBytes); Device::getHal().Allocation1DRead(mContext, _allocation, _xoff, _lod, _count, _data, _sizeBytes); return Void(); } Return Context::allocationElementRead(Allocation allocation, uint32_t x, uint32_t y, uint32_t z, uint32_t lod, Ptr data, Size sizeBytes, Size compIdx) { RsAllocation _allocation = hidl_to_rs(allocation); uint32_t _x = x; uint32_t _y = y; uint32_t _z = z; uint32_t _lod = lod; void* _data = hidl_to_rs(data); size_t _sizeBytes = static_cast(sizeBytes); size_t _compIdx = static_cast(compIdx); Device::getHal().AllocationElementRead(mContext, _allocation, _x, _y, _z, _lod, _data, _sizeBytes, _compIdx); return Void(); } Return Context::allocation2DRead(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t lod, AllocationCubemapFace face, uint32_t w, uint32_t h, Ptr data, Size sizeBytes, Size stride) { RsAllocation _allocation = hidl_to_rs(allocation); uint32_t _xoff = xoff; uint32_t _yoff = yoff; uint32_t _lod = lod; RsAllocationCubemapFace _face = static_cast(face); uint32_t _w = w; uint32_t _h = h; void* _data = hidl_to_rs(data); size_t _sizeBytes = static_cast(sizeBytes); size_t _stride = static_cast(stride); Device::getHal().Allocation2DRead(mContext, _allocation, _xoff, _yoff, _lod, _face, _w, _h, _data, _sizeBytes, _stride); return Void(); } Return Context::allocation3DRead(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod, uint32_t w, uint32_t h, uint32_t d, Ptr data, Size sizeBytes, Size stride) { RsAllocation _allocation = hidl_to_rs(allocation); uint32_t _xoff = xoff; uint32_t _yoff = yoff; uint32_t _zoff = zoff; uint32_t _lod = lod; uint32_t _w = w; uint32_t _h = h; uint32_t _d = d; void* _dataPtr = hidl_to_rs(data); size_t _sizeBytes = static_cast(sizeBytes); size_t _stride = static_cast(stride); Device::getHal().Allocation3DRead(mContext, _allocation, _xoff, _yoff, _zoff, _lod, _w, _h, _d, _dataPtr, _sizeBytes, _stride); return Void(); } Return Context::allocationSyncAll(Allocation allocation, AllocationUsageType usageType) { RsAllocation _allocation = hidl_to_rs(allocation); RsAllocationUsageType _usageType = static_cast(usageType); Device::getHal().AllocationSyncAll(mContext, _allocation, _usageType); return Void(); } Return Context::allocationResize1D(Allocation allocation, uint32_t dimX) { RsAllocation _allocation = hidl_to_rs(allocation); uint32_t _dimX = dimX; Device::getHal().AllocationResize1D(mContext, _allocation, _dimX); return Void(); } Return Context::allocationCopy2DRange(Allocation dstAlloc, uint32_t dstXoff, uint32_t dstYoff, uint32_t dstMip, AllocationCubemapFace dstFace, uint32_t width, uint32_t height, Allocation srcAlloc, uint32_t srcXoff, uint32_t srcYoff, uint32_t srcMip, AllocationCubemapFace srcFace) { RsAllocation _dstAlloc = hidl_to_rs(dstAlloc); uint32_t _dstXoff = dstXoff; uint32_t _dstYoff = dstYoff; uint32_t _dstMip = dstMip; RsAllocationCubemapFace _dstFace = static_cast(dstFace); uint32_t _width = width; uint32_t _height = height; RsAllocation _srcAlloc = hidl_to_rs(srcAlloc); uint32_t _srcXoff = srcXoff; uint32_t _srcYoff = srcYoff; uint32_t _srcMip = srcMip; RsAllocationCubemapFace _srcFace = static_cast(srcFace); Device::getHal().AllocationCopy2DRange(mContext, _dstAlloc, _dstXoff, _dstYoff, _dstMip, _dstFace, _width, _height, _srcAlloc, _srcXoff, _srcYoff, _srcMip, _srcFace); return Void(); } Return Context::allocationCopy3DRange(Allocation dstAlloc, uint32_t dstXoff, uint32_t dstYoff, uint32_t dstZoff, uint32_t dstMip, uint32_t width, uint32_t height, uint32_t depth, Allocation srcAlloc, uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff, uint32_t srcMip) { RsAllocation _dstAlloc = hidl_to_rs(dstAlloc); uint32_t _dstXoff = dstXoff; uint32_t _dstYoff = dstYoff; uint32_t _dstZoff = dstZoff; uint32_t _dstMip = dstMip; uint32_t _width = width; uint32_t _height = height; uint32_t _depth = depth; RsAllocation _srcAlloc = hidl_to_rs(srcAlloc); uint32_t _srcXoff = srcXoff; uint32_t _srcYoff = srcYoff; uint32_t _srcZoff = srcZoff; uint32_t _srcMip = srcMip; Device::getHal().AllocationCopy3DRange(mContext, _dstAlloc, _dstXoff, _dstYoff, _dstZoff, _dstMip, _width, _height, _depth, _srcAlloc, _srcXoff, _srcYoff, _srcZoff, _srcMip); return Void(); } Return Context::allocationIoSend(Allocation allocation) { RsAllocation _allocation = hidl_to_rs(allocation); Device::getHal().AllocationIoSend(mContext, _allocation); return Void(); } Return Context::allocationIoReceive(Allocation allocation) { RsAllocation _allocation = hidl_to_rs(allocation); Device::getHal().AllocationIoReceive(mContext, _allocation); return Void(); } Return Context::allocationGetPointer(Allocation allocation, uint32_t lod, AllocationCubemapFace face, uint32_t z, allocationGetPointer_cb _hidl_cb) { RsAllocation _allocation = hidl_to_rs(allocation); uint32_t _lod = lod; RsAllocationCubemapFace _face = static_cast(face); uint32_t _z = z; uint32_t _array = 0; size_t _stride = 0; void* _dataPtr = Device::getHal().AllocationGetPointer(mContext, _allocation, _lod, _face, _z, _array, &_stride, sizeof(size_t)); Ptr dataPtr = reinterpret_cast(_dataPtr); Size stride = static_cast(_stride); _hidl_cb(dataPtr, stride); return Void(); } Return Context::elementGetNativeMetadata(Element element, elementGetNativeMetadata_cb _hidl_cb) { RsElement _element = hidl_to_rs(element); std::vector _elemData(5); Device::getHal().ElementGetNativeData(mContext, _element, _elemData.data(), _elemData.size()); hidl_vec elemData = _elemData; _hidl_cb(elemData); return Void(); } Return Context::elementGetSubElements(Element element, Size numSubElem, elementGetSubElements_cb _hidl_cb) { RsElement _element = hidl_to_rs(element); uint32_t _numSubElem = static_cast(numSubElem); std::vector _ids(_numSubElem); std::vector _names(_numSubElem); std::vector _arraySizes(_numSubElem); Device::getHal().ElementGetSubElements(mContext, _element, _ids.data(), _names.data(), _arraySizes.data(), _numSubElem); hidl_vec ids = rs_to_hidl(_ids, [](uintptr_t val) { return static_cast(val); }); hidl_vec names = rs_to_hidl(_names, [](const char* val) { return val; }); hidl_vec arraySizes = rs_to_hidl(_arraySizes, [](size_t val) { return static_cast(val); }); _hidl_cb(ids, names, arraySizes); return Void(); } Return Context::elementCreate(DataType dt, DataKind dk, bool norm, uint32_t size) { RsDataType _dt = static_cast(dt); RsDataKind _dk = static_cast(dk); bool _norm = norm; uint32_t _size = size; RsElement _element = Device::getHal().ElementCreate(mContext, _dt, _dk, _norm, _size); return rs_to_hidl(_element); } Return Context::elementComplexCreate(const hidl_vec& eins, const hidl_vec& names, const hidl_vec& arraySizes) { std::vector _eins = hidl_to_rs(eins, [](Element val) { return hidl_to_rs(val); }); std::vector _namesPtr = hidl_to_rs(names, [](const hidl_string& val) { return val.c_str(); }); std::vector _nameLengthsPtr = hidl_to_rs(names, [](const hidl_string& val) { return val.size(); }); std::vector _arraySizes = hidl_to_rs(arraySizes, [](Size val) { return static_cast(val); }); RsElement _element = Device::getHal().ElementCreate2(mContext, _eins.data(), _eins.size(), _namesPtr.data(), _namesPtr.size(), _nameLengthsPtr.data(), _arraySizes.data(), _arraySizes.size()); return rs_to_hidl(_element); } Return Context::typeGetNativeMetadata(Type type, typeGetNativeMetadata_cb _hidl_cb) { RsType _type = hidl_to_rs(type); std::vector _metadata(6); Device::getHal().TypeGetNativeData(mContext, _type, _metadata.data(), _metadata.size()); hidl_vec metadata = rs_to_hidl(_metadata, [](uintptr_t val) { return static_cast(val); }); _hidl_cb(metadata); return Void(); } Return Context::typeCreate(Element element, uint32_t dimX, uint32_t dimY, uint32_t dimZ, bool mipmaps, bool faces, YuvFormat yuv) { RsElement _element = hidl_to_rs(element); uint32_t _dimX = dimX; uint32_t _dimY = dimY; uint32_t _dimZ = dimZ; bool _mipmaps = mipmaps; bool _faces = faces; RsYuvFormat _yuv = static_cast(yuv); RsType _type = Device::getHal().TypeCreate(mContext, _element, _dimX, _dimY, _dimZ, _mipmaps, _faces, _yuv); return rs_to_hidl(_type); } Return Context::contextDestroy() { Device::getHal().ContextDestroy(mContext); mContext = nullptr; return Void(); } Return Context::contextGetMessage(Ptr data, Size size, contextGetMessage_cb _hidl_cb) { void* _data = hidl_to_rs(data); size_t _size = static_cast(size); size_t _receiveLen = 0; uint32_t _subID = 0; RsMessageToClientType _messageType = Device::getHal().ContextGetMessage(mContext, _data, _size, &_receiveLen, sizeof(size_t), &_subID, sizeof(uint32_t)); MessageToClientType messageType = static_cast(_messageType); Size receiveLen = static_cast(_receiveLen); _hidl_cb(messageType, receiveLen); return Void(); } Return Context::contextPeekMessage(contextPeekMessage_cb _hidl_cb) { size_t _receiveLen = 0; uint32_t _subID = 0; RsMessageToClientType _messageType = Device::getHal().ContextPeekMessage(mContext, &_receiveLen, sizeof(size_t), &_subID, sizeof(uint32_t)); MessageToClientType messageType = static_cast(_messageType); Size receiveLen = static_cast(_receiveLen); uint32_t subID = _subID; _hidl_cb(messageType, receiveLen, subID); return Void(); } Return Context::contextSendMessage(uint32_t id, const hidl_vec& data) { uint32_t _id = id; const uint8_t* _dataPtr = data.data(); size_t _dataSize = data.size(); Device::getHal().ContextSendMessage(mContext, _id, _dataPtr, _dataSize); return Void(); } Return Context::contextInitToClient() { Device::getHal().ContextInitToClient(mContext); return Void(); } Return Context::contextDeinitToClient() { Device::getHal().ContextDeinitToClient(mContext); return Void(); } Return Context::contextFinish() { Device::getHal().ContextFinish(mContext); return Void(); } Return Context::contextLog() { uint32_t _bits = 0; Device::getHal().ContextDump(mContext, _bits); return Void(); } Return Context::contextSetPriority(ThreadPriorities priority) { RsThreadPriorities _priority = static_cast(priority); Device::getHal().ContextSetPriority(mContext, _priority); return Void(); } Return Context::contextSetCacheDir(const hidl_string& cacheDir) { Device::getHal().ContextSetCacheDir(mContext, cacheDir.c_str(), cacheDir.size()); return Void(); } Return Context::assignName(ObjectBase obj, const hidl_string& name) { RsObjectBase _obj = hidl_to_rs(obj); const hidl_string& _name = name; Device::getHal().AssignName(mContext, _obj, _name.c_str(), _name.size()); return Void(); } Return Context::getName(ObjectBase obj, getName_cb _hidl_cb) { void* _obj = hidl_to_rs(obj); const char* _name = nullptr; Device::getHal().GetName(mContext, _obj, &_name); hidl_string name = _name; _hidl_cb(name); return Void(); } Return Context::closureCreate(ScriptKernelID kernelID, Allocation returnValue, const hidl_vec& fieldIDS, const hidl_vec& values, const hidl_vec& sizes, const hidl_vec& depClosures, const hidl_vec& depFieldIDS) { RsScriptKernelID _kernelID = hidl_to_rs(kernelID); RsAllocation _returnValue = hidl_to_rs(returnValue); std::vector _fieldIDS = hidl_to_rs(fieldIDS, [](ScriptFieldID val) { return hidl_to_rs(val); }); int64_t* _valuesPtr = const_cast(values.data()); size_t _valuesLength = values.size(); std::vector _sizes = hidl_to_rs(sizes, [](int32_t val) { return static_cast(val); }); std::vector _depClosures = hidl_to_rs(depClosures, [](Closure val) { return hidl_to_rs(val); }); std::vector _depFieldIDS = hidl_to_rs(depFieldIDS, [](ScriptFieldID val) { return hidl_to_rs(val); }); RsClosure _closure = Device::getHal().ClosureCreate(mContext, _kernelID, _returnValue, _fieldIDS.data(), _fieldIDS.size(), _valuesPtr, _valuesLength, _sizes.data(), _sizes.size(), _depClosures.data(), _depClosures.size(), _depFieldIDS.data(), _depFieldIDS.size()); return rs_to_hidl(_closure); } Return Context::invokeClosureCreate(ScriptInvokeID invokeID, const hidl_vec& params, const hidl_vec& fieldIDS, const hidl_vec& values, const hidl_vec& sizes) { RsScriptInvokeID _invokeID = hidl_to_rs(invokeID); const void* _paramsPtr = params.data(); size_t _paramsSize = params.size(); std::vector _fieldIDS = hidl_to_rs(fieldIDS, [](ScriptFieldID val) { return hidl_to_rs(val); }); const int64_t* _valuesPtr = values.data(); size_t _valuesLength = values.size(); std::vector _sizes = hidl_to_rs(sizes, [](int32_t val) { return static_cast(val); }); RsClosure _closure = Device::getHal().InvokeClosureCreate(mContext, _invokeID, _paramsPtr, _paramsSize, _fieldIDS.data(), _fieldIDS.size(), _valuesPtr, _valuesLength, _sizes.data(), _sizes.size()); return rs_to_hidl(_closure); } Return Context::closureSetArg(Closure closure, uint32_t index, Ptr value, int32_t size) { RsClosure _closure = hidl_to_rs(closure); uint32_t _index = index; uintptr_t _value = hidl_to_rs(value); int _size = static_cast(size); Device::getHal().ClosureSetArg(mContext, _closure, _index, _value, _size); return Void(); } Return Context::closureSetGlobal(Closure closure, ScriptFieldID fieldID, int64_t value, int32_t size) { RsClosure _closure = hidl_to_rs(closure); RsScriptFieldID _fieldID = hidl_to_rs(fieldID); int64_t _value = value; int _size = static_cast(size); Device::getHal().ClosureSetGlobal(mContext, _closure, _fieldID, _value, _size); return Void(); } Return Context::scriptKernelIDCreate(Script script, int32_t slot, int32_t sig) { RsScript _script = hidl_to_rs(script); int _slot = static_cast(slot); int _sig = static_cast(sig); RsScriptKernelID _scriptKernelID = Device::getHal().ScriptKernelIDCreate(mContext, _script, _slot, _sig); return rs_to_hidl(_scriptKernelID); } Return Context::scriptInvokeIDCreate(Script script, int32_t slot) { RsScript _script = hidl_to_rs(script); int _slot = static_cast(slot); RsScriptInvokeID _scriptInvokeID = Device::getHal().ScriptInvokeIDCreate(mContext, _script, _slot); return rs_to_hidl(_scriptInvokeID); } Return Context::scriptFieldIDCreate(Script script, int32_t slot) { RsScript _script = hidl_to_rs(script); int _slot = static_cast(slot); RsScriptFieldID _scriptFieldID = Device::getHal().ScriptFieldIDCreate(mContext, _script, _slot); return rs_to_hidl(_scriptFieldID); } Return Context::scriptGroupCreate(const hidl_vec& kernels, const hidl_vec& srcK, const hidl_vec& dstK, const hidl_vec& dstF, const hidl_vec& types) { std::vector _kernels = hidl_to_rs(kernels, [](ScriptFieldID val) { return hidl_to_rs(val); }); std::vector _srcK = hidl_to_rs(srcK, [](ScriptFieldID val) { return hidl_to_rs(val); }); std::vector _dstK = hidl_to_rs(dstK, [](ScriptFieldID val) { return hidl_to_rs(val); }); std::vector _dstF = hidl_to_rs(dstF, [](ScriptFieldID val) { return hidl_to_rs(val); }); std::vector _types = hidl_to_rs(types, [](Type val) { return hidl_to_rs(val); }); RsScriptGroup _scriptGroup = Device::getHal().ScriptGroupCreate(mContext, _kernels.data(), _kernels.size() * sizeof(RsScriptKernelID), _srcK.data(), _srcK.size() * sizeof(RsScriptKernelID), _dstK.data(), _dstK.size() * sizeof(RsScriptKernelID), _dstF.data(), _dstF.size() * sizeof(RsScriptFieldID), _types.data(), _types.size() * sizeof(RsType)); return rs_to_hidl(_scriptGroup); } Return Context::scriptGroup2Create(const hidl_string& name, const hidl_string& cacheDir, const hidl_vec& closures) { const hidl_string& _name = name; const hidl_string& _cacheDir = cacheDir; std::vector _closures = hidl_to_rs(closures, [](Closure val) { return hidl_to_rs(val); }); RsScriptGroup2 _scriptGroup2 = Device::getHal().ScriptGroup2Create(mContext, _name.c_str(), _name.size(), _cacheDir.c_str(), _cacheDir.size(), _closures.data(), _closures.size()); return rs_to_hidl(_scriptGroup2); } Return Context::scriptGroupSetOutput(ScriptGroup sg, ScriptKernelID kid, Allocation alloc) { RsScriptGroup _sg = hidl_to_rs(sg); RsScriptKernelID _kid = hidl_to_rs(kid); RsAllocation _alloc = hidl_to_rs(alloc); Device::getHal().ScriptGroupSetOutput(mContext, _sg, _kid, _alloc); return Void(); } Return Context::scriptGroupSetInput(ScriptGroup sg, ScriptKernelID kid, Allocation alloc) { RsScriptGroup _sg = hidl_to_rs(sg); RsScriptKernelID _kid = hidl_to_rs(kid); RsAllocation _alloc = hidl_to_rs(alloc); Device::getHal().ScriptGroupSetInput(mContext, _sg, _kid, _alloc); return Void(); } Return Context::scriptGroupExecute(ScriptGroup sg) { RsScriptGroup _sg = hidl_to_rs(sg); Device::getHal().ScriptGroupExecute(mContext, _sg); return Void(); } Return Context::objDestroy(ObjectBase obj) { RsAsyncVoidPtr _obj = hidl_to_rs(obj); Device::getHal().ObjDestroy(mContext, _obj); return Void(); } Return Context::samplerCreate(SamplerValue magFilter, SamplerValue minFilter, SamplerValue wrapS, SamplerValue wrapT, SamplerValue wrapR, float aniso) { RsSamplerValue _magFilter = static_cast(magFilter); RsSamplerValue _minFilter = static_cast(minFilter); RsSamplerValue _wrapS = static_cast(wrapS); RsSamplerValue _wrapT = static_cast(wrapT); RsSamplerValue _wrapR = static_cast(wrapR); float _aniso = static_cast(aniso); RsSampler _sampler = Device::getHal().SamplerCreate(mContext, _magFilter, _minFilter, _wrapS, _wrapT, _wrapR, _aniso); return rs_to_hidl(_sampler); } Return Context::scriptBindAllocation(Script script, Allocation allocation, uint32_t slot) { RsScript _script = hidl_to_rs(script); RsAllocation _allocation = hidl_to_rs(allocation); uint32_t _slot = slot; Device::getHal().ScriptBindAllocation(mContext, _script, _allocation, _slot); return Void(); } Return Context::scriptSetTimeZone(Script script, const hidl_string& timeZone) { RsScript _script = hidl_to_rs(script); const hidl_string& _timeZone = timeZone; Device::getHal().ScriptSetTimeZone(mContext, _script, _timeZone.c_str(), _timeZone.size()); return Void(); } Return Context::scriptInvoke(Script vs, uint32_t slot) { RsScript _vs = hidl_to_rs(vs); uint32_t _slot = slot; Device::getHal().ScriptInvoke(mContext, _vs, _slot); return Void(); } Return Context::scriptInvokeV(Script vs, uint32_t slot, const hidl_vec& data) { RsScript _vs = hidl_to_rs(vs); uint32_t _slot = slot; const void* _dataPtr = hidl_to_rs(data.data()); size_t _len = data.size(); Device::getHal().ScriptInvokeV(mContext, _vs, _slot, _dataPtr, _len); return Void(); } Return Context::scriptForEach(Script vs, uint32_t slot, const hidl_vec& vains, Allocation vaout, const hidl_vec& params, Ptr sc) { RsScript _vs = hidl_to_rs(vs); uint32_t _slot = slot; std::vector _vains = hidl_to_rs(vains, [](Allocation val) { return hidl_to_rs(val); }); RsAllocation _vaout = hidl_to_rs(vaout); const void* _paramsPtr = hidl_to_rs(params.data()); size_t _paramLen = params.size(); const RsScriptCall* _sc = hidl_to_rs(sc); size_t _scLen = _sc != nullptr ? sizeof(ScriptCall) : 0; Device::getHal().ScriptForEachMulti(mContext, _vs, _slot, _vains.data(), _vains.size(), _vaout, _paramsPtr, _paramLen, _sc, _scLen); return Void(); } Return Context::scriptReduce(Script vs, uint32_t slot, const hidl_vec& vains, Allocation vaout, Ptr sc) { RsScript _vs = hidl_to_rs(vs); uint32_t _slot = slot; std::vector _vains = hidl_to_rs(vains, [](Allocation val) { return hidl_to_rs(val); }); RsAllocation _vaout = hidl_to_rs(vaout); const RsScriptCall* _sc = hidl_to_rs(sc); size_t _scLen = _sc != nullptr ? sizeof(ScriptCall) : 0; Device::getHal().ScriptReduce(mContext, _vs, _slot, _vains.data(), _vains.size(), _vaout, _sc, _scLen); return Void(); } Return Context::scriptSetVarI(Script vs, uint32_t slot, int32_t value) { RsScript _vs = hidl_to_rs(vs); uint32_t _slot = slot; int _value = static_cast(value); Device::getHal().ScriptSetVarI(mContext, _vs, _slot, _value); return Void(); } Return Context::scriptSetVarObj(Script vs, uint32_t slot, ObjectBase obj) { RsScript _vs = hidl_to_rs(vs); uint32_t _slot = slot; RsObjectBase _obj = hidl_to_rs(obj); Device::getHal().ScriptSetVarObj(mContext, _vs, _slot, _obj); return Void(); } Return Context::scriptSetVarJ(Script vs, uint32_t slot, int64_t value) { RsScript _vs = hidl_to_rs(vs); uint32_t _slot = slot; int64_t _value = static_cast(value); Device::getHal().ScriptSetVarJ(mContext, _vs, _slot, _value); return Void(); } Return Context::scriptSetVarF(Script vs, uint32_t slot, float value) { RsScript _vs = hidl_to_rs(vs); uint32_t _slot = slot; float _value = value; Device::getHal().ScriptSetVarF(mContext, _vs, _slot, _value); return Void(); } Return Context::scriptSetVarD(Script vs, uint32_t slot, double value) { RsScript _vs = hidl_to_rs(vs); uint32_t _slot = slot; double _value = value; Device::getHal().ScriptSetVarD(mContext, _vs, _slot, _value); return Void(); } Return Context::scriptSetVarV(Script vs, uint32_t slot, const hidl_vec& data) { RsScript _vs = hidl_to_rs(vs); uint32_t _slot = slot; const void* _dataPtr = hidl_to_rs(data.data()); size_t _len = data.size(); Device::getHal().ScriptSetVarV(mContext, _vs, _slot, _dataPtr, _len); return Void(); } Return Context::scriptGetVarV(Script vs, uint32_t slot, Size len, scriptGetVarV_cb _hidl_cb) { RsScript _vs = hidl_to_rs(vs); uint32_t _slot = slot; size_t _len = static_cast(len); std::vector _data(_len); Device::getHal().ScriptGetVarV(mContext, _vs, _slot, _data.data(), _data.size()); hidl_vec data = _data; _hidl_cb(data); return Void(); } Return Context::scriptSetVarVE(Script vs, uint32_t slot, const hidl_vec& data, Element ve, const hidl_vec& dims) { RsScript _vs = hidl_to_rs(vs); uint32_t _slot = slot; const void* _dataPtr = hidl_to_rs(data.data()); size_t _len = data.size(); RsElement _ve = hidl_to_rs(ve); const uint32_t* _dimsPtr = dims.data(); size_t _dimLen = dims.size() * sizeof(uint32_t); Device::getHal().ScriptSetVarVE(mContext, _vs, _slot, _dataPtr, _len, _ve, _dimsPtr, _dimLen); return Void(); } Return