| /* |
| * 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 "rsApiStubs.h" |
| #include "rsHidlAdaptation.h" |
| #include "rsFallbackAdaptation.h" |
| #include "cpp/rsDispatch.h" |
| |
| #include <log/log.h> |
| #include <dlfcn.h> |
| |
| #include <mutex> |
| #include <map> |
| |
| #undef LOG_TAG |
| #define LOG_TAG "RenderScript" |
| |
| // TODO: Figure out how to use different declared types for the two interfaces |
| // to avoid the confusion. Currently, RsContext is used as the API type for |
| // both the client interface and the dispatch table interface, but at the |
| // client interface it's really RsContextWrapper* instead. |
| // TODO: Figure out how to better design class hierarchy for all these Contexts. |
| // RsContextWrapper wraps the RsContext and corresponding dispatchTable pointer. |
| // The wrapper object is created during ContextCreate, and the address of the |
| // object is returned to Java / C++, instead of the RsContext handle. |
| // The wrapper object is destroyed during ContextDestroy to release the memory. |
| struct RsContextWrapper { |
| RsContext context; |
| const dispatchTable* dispatch; |
| }; |
| |
| #define RS_DISPATCH(opaqueWrapper, func, ...) \ |
| [&]() { \ |
| const RsContextWrapper *wrapper = reinterpret_cast<RsContextWrapper *>(opaqueWrapper); \ |
| RsContext context = wrapper->context; \ |
| return wrapper->dispatch->func(context, ##__VA_ARGS__); \ |
| }() |
| |
| |
| // contextMap maps RsContext to the corresponding RsContextWrapper pointer. |
| static std::map<RsContext, RsContextWrapper* > contextMap; |
| |
| // contextMapMutex is used to protect concurrent access of the contextMap. |
| // std::mutex is safe for pthreads on Android. Since other threading model |
| // supported on Android are built on top of pthread, std::mutex is safe for them. |
| static std::mutex contextMapMutex; |
| |
| // globalObjAlive is a global flag indicating whether the global objects, |
| // contextMap & contextMapMutex, are still alive. |
| // For the protected functions during application teardown, this |
| // flag will be checked before accessing the global objects. |
| static bool globalObjAlive; |
| |
| // GlobalObjGuard manipulates the globalObjAlive flag during construction and |
| // destruction. If the guard object is destroyed, globalObjAlive will be set |
| // to false, which will make the protected functions NO-OP. |
| // https://goto.google.com/rs-static-destructor |
| class GlobalObjGuard { |
| public: |
| GlobalObjGuard() { |
| globalObjAlive = true; |
| } |
| |
| ~GlobalObjGuard() { |
| globalObjAlive = false; |
| } |
| }; |
| static GlobalObjGuard guard; |
| |
| // API to find high-level context (RsContextWrapper) given a low level context. |
| // This API is only intended to be used by RenderScript debugger. |
| extern "C" RsContext rsDebugGetHighLevelContext(RsContext context) { |
| std::unique_lock<std::mutex> lock(contextMapMutex); |
| return contextMap.at(context); |
| } |
| |
| // Device |
| // These API stubs are kept here to maintain backward compatibility, |
| // but they are not actually doing anything. |
| |
| extern "C" RsDevice rsDeviceCreate() |
| { |
| return (void *) 1; |
| } |
| extern "C" void rsDeviceDestroy(RsDevice dev) |
| { |
| } |
| extern "C" void rsDeviceSetConfig(RsDevice dev, RsDeviceParam p, int32_t value) |
| { |
| } |
| |
| /* |
| * This global will be found by the debugger and will have its value flipped. |
| * It's independent of the Context class to allow the debugger to do the above |
| * without knowing the type makeup. This allows the debugger to be attached at |
| * an earlier stage. |
| */ |
| extern "C" int gDebuggerPresent = 0; |
| |
| namespace{ |
| // Check if the calling process is a vendor process or not. |
| static bool isVendorProcess() { |
| char path[PATH_MAX]; |
| ssize_t path_len = readlink("/proc/self/exe", path, sizeof(path)); |
| if (path_len == -1) { |
| return false; |
| } |
| // Vendor process will return "/vendor/*" |
| static const char vendor_path[] = "/vendor/"; |
| return !strncmp(path, vendor_path, sizeof(vendor_path)-1); |
| } |
| |
| typedef const char* (*QueryCacheDirFnPtr)(); |
| // Dynamically load the queryCacheDir function pointer, so that for vendor |
| // processes, libandroid_runtime.so will not be loaded. |
| static QueryCacheDirFnPtr loadQueryCacheFnPtr() { |
| QueryCacheDirFnPtr queryCacheDir = nullptr; |
| void* handle = dlopen("libRSCacheDir.so", RTLD_LAZY | RTLD_LOCAL); |
| if (!handle || |
| !(queryCacheDir = (QueryCacheDirFnPtr)dlsym(handle, "rsQueryCacheDir"))) { |
| ALOGW("Not able to query cache dir: %s", dlerror()); |
| } |
| return queryCacheDir; |
| } |
| } // anonymous namespace |
| |
| // Context |
| extern "C" RsContext rsContextCreate(RsDevice vdev, uint32_t version, uint32_t sdkVersion, |
| RsContextType ct, uint32_t flags) |
| { |
| if (!globalObjAlive) { |
| ALOGE("rsContextCreate is not allowed during process teardown."); |
| return nullptr; |
| } |
| |
| RsContext context; |
| RsContextWrapper *ctxWrapper; |
| |
| if (flags & RS_CONTEXT_LOW_LATENCY) { |
| // Use CPU path for LOW_LATENCY context. |
| RsFallbackAdaptation& instance = RsFallbackAdaptation::GetInstance(); |
| context = instance.GetEntryFuncs()->ContextCreate(vdev, version, sdkVersion, ct, flags); |
| ctxWrapper = new RsContextWrapper{context, instance.GetEntryFuncs()}; |
| } else { |
| RsHidlAdaptation& instance = RsHidlAdaptation::GetInstance(); |
| context = instance.GetEntryFuncs()->ContextCreate(vdev, version, sdkVersion, ct, flags); |
| ctxWrapper = new RsContextWrapper{context, instance.GetEntryFuncs()}; |
| |
| // Use function local static variables to ensure thread safety. |
| static QueryCacheDirFnPtr queryCacheDir = isVendorProcess() ? nullptr : loadQueryCacheFnPtr(); |
| if (queryCacheDir) { |
| static std::string defaultCacheDir = std::string(queryCacheDir()); |
| if (defaultCacheDir.size() > 0) { |
| ALOGD("Setting cache dir: %s", defaultCacheDir.c_str()); |
| rsContextSetCacheDir(ctxWrapper, |
| defaultCacheDir.c_str(), |
| defaultCacheDir.size()); |
| } |
| } |
| } |
| |
| // Wait for debugger to attach if RS_CONTEXT_WAIT_FOR_ATTACH flag set. |
| if (flags & RS_CONTEXT_WAIT_FOR_ATTACH) { |
| while (!gDebuggerPresent) { |
| sleep(0); |
| } |
| } |
| |
| // Lock contextMap when adding new entries. |
| std::unique_lock<std::mutex> lock(contextMapMutex); |
| contextMap.insert(std::make_pair(context, ctxWrapper)); |
| |
| return (RsContext) ctxWrapper; |
| } |
| |
| extern "C" void rsContextDestroy (RsContext ctxWrapper) |
| { |
| if (!globalObjAlive) { |
| return; |
| } |
| |
| RS_DISPATCH(ctxWrapper, ContextDestroy); |
| |
| // Lock contextMap when deleting an existing entry. |
| std::unique_lock<std::mutex> lock(contextMapMutex); |
| contextMap.erase(reinterpret_cast< RsContextWrapper* >(ctxWrapper)->context); |
| |
| delete (RsContextWrapper *)ctxWrapper; |
| } |
| |
| extern "C" void rsContextFinish (RsContext ctxWrapper) |
| { |
| RS_DISPATCH(ctxWrapper, ContextFinish); |
| } |
| |
| extern "C" void rsContextDump (RsContext ctxWrapper, int32_t bits) |
| { |
| RS_DISPATCH(ctxWrapper, ContextDump, bits); |
| } |
| |
| extern "C" void rsContextSetPriority (RsContext ctxWrapper, int32_t priority) |
| { |
| RS_DISPATCH(ctxWrapper, ContextSetPriority, priority); |
| } |
| |
| extern "C" void rsContextDestroyWorker (RsContext ctxWrapper) |
| { |
| } |
| |
| extern "C" RsMessageToClientType rsContextGetMessage (RsContext ctxWrapper, void * data, size_t data_length, |
| size_t * receiveLen, size_t receiveLen_length, |
| uint32_t * usrID, size_t usrID_length) |
| { |
| return RS_DISPATCH(ctxWrapper, ContextGetMessage, data, data_length, |
| receiveLen, receiveLen_length, |
| usrID, usrID_length); |
| } |
| |
| extern "C" RsMessageToClientType rsContextPeekMessage (RsContext ctxWrapper, |
| size_t * receiveLen, size_t receiveLen_length, |
| uint32_t * usrID, size_t usrID_length) |
| { |
| return RS_DISPATCH(ctxWrapper, ContextPeekMessage, |
| receiveLen, receiveLen_length, |
| usrID, usrID_length); |
| } |
| |
| extern "C" void rsContextSendMessage (RsContext ctxWrapper, uint32_t id, const uint8_t * data, size_t data_length) |
| { |
| RS_DISPATCH(ctxWrapper, ContextSendMessage, id, data, data_length); |
| } |
| |
| extern "C" void rsContextInitToClient (RsContext ctxWrapper) |
| { |
| RS_DISPATCH(ctxWrapper, ContextInitToClient); |
| } |
| |
| extern "C" void rsContextDeinitToClient (RsContext ctxWrapper) |
| { |
| RS_DISPATCH(ctxWrapper, ContextDeinitToClient); |
| } |
| |
| extern "C" void rsContextSetCacheDir (RsContext ctxWrapper, const char * cacheDir, size_t cacheDir_length) |
| { |
| RS_DISPATCH(ctxWrapper, ContextSetCacheDir, cacheDir, cacheDir_length); |
| } |
| |
| extern "C" void rsaContextSetNativeLibDir(RsContext ctxWrapper, char *libDir, size_t length) |
| { |
| } |
| |
| // BaseObject |
| |
| extern "C" void rsAssignName (RsContext ctxWrapper, RsObjectBase obj, const char * name, size_t name_length) |
| { |
| RS_DISPATCH(ctxWrapper, AssignName, obj, name, name_length); |
| } |
| |
| extern "C" void rsaGetName(RsContext ctxWrapper, void * obj, const char **name) |
| { |
| RS_DISPATCH(ctxWrapper, GetName, obj, name); |
| } |
| |
| extern "C" void rsObjDestroy (RsContext ctxWrapper, RsAsyncVoidPtr objPtr) |
| { |
| RS_DISPATCH(ctxWrapper, ObjDestroy, objPtr); |
| } |
| |
| // Element |
| |
| extern "C" RsElement rsElementCreate (RsContext ctxWrapper, RsDataType mType, RsDataKind mKind, |
| bool mNormalized, uint32_t mVectorSize) |
| { |
| return RS_DISPATCH(ctxWrapper, ElementCreate, mType, mKind, mNormalized, mVectorSize); |
| } |
| |
| extern "C" RsElement rsElementCreate2 (RsContext ctxWrapper, const RsElement * elements, size_t elements_length, |
| const char ** names, size_t names_length_length, const size_t * names_length, |
| const uint32_t * arraySize, size_t arraySize_length) |
| { |
| return RS_DISPATCH(ctxWrapper, ElementCreate2, |
| elements, elements_length, |
| names, names_length_length, names_length, |
| arraySize, arraySize_length); |
| } |
| |
| extern "C" void rsaElementGetNativeData(RsContext ctxWrapper, RsElement elem, uint32_t *elemData, uint32_t elemDataSize) |
| { |
| RS_DISPATCH(ctxWrapper, ElementGetNativeData, elem, elemData, elemDataSize); |
| } |
| |
| extern "C" void rsaElementGetSubElements(RsContext ctxWrapper, RsElement elem, uintptr_t *ids, const char **names, |
| size_t *arraySizes, uint32_t dataSize) |
| { |
| RS_DISPATCH(ctxWrapper, ElementGetSubElements, elem, ids, names, arraySizes, dataSize); |
| } |
| |
| // Type |
| |
| extern "C" RsType rsTypeCreate (RsContext ctxWrapper, RsElement e, uint32_t dimX, uint32_t dimY, uint32_t dimZ, |
| bool mipmaps, bool faces, uint32_t yuv) |
| { |
| return RS_DISPATCH(ctxWrapper, TypeCreate, e, dimX, dimY, dimZ, mipmaps, faces, yuv); |
| } |
| |
| extern "C" RsType rsTypeCreate2 (RsContext ctxWrapper, const RsTypeCreateParams * dat, size_t dat_length) |
| { |
| return nullptr; |
| } |
| |
| extern "C" void rsaTypeGetNativeData(RsContext ctxWrapper, RsType type, uintptr_t *typeData, uint32_t typeDataSize) |
| { |
| RS_DISPATCH(ctxWrapper, TypeGetNativeData, type, typeData, typeDataSize); |
| } |
| |
| |
| // Allocation |
| |
| extern "C" RsAllocation rsAllocationCreateTyped (RsContext ctxWrapper, RsType vtype, RsAllocationMipmapControl mipmaps, |
| uint32_t usages, uintptr_t ptr) |
| { |
| return RS_DISPATCH(ctxWrapper, AllocationCreateTyped, vtype, mipmaps, usages, ptr); |
| } |
| |
| extern "C" RsAllocation rsAllocationCreateFromBitmap (RsContext ctxWrapper, RsType vtype, RsAllocationMipmapControl mipmaps, |
| const void * data, size_t data_length, uint32_t usages) |
| { |
| return RS_DISPATCH(ctxWrapper, AllocationCreateFromBitmap, vtype, mipmaps, data, data_length, usages); |
| } |
| |
| extern "C" RsAllocation rsAllocationCubeCreateFromBitmap (RsContext ctxWrapper, RsType vtype, RsAllocationMipmapControl mipmaps, |
| const void * data, size_t data_length, uint32_t usages) |
| { |
| return RS_DISPATCH(ctxWrapper, AllocationCubeCreateFromBitmap, vtype, mipmaps, data, data_length, usages); |
| } |
| |
| extern "C" RsAllocation rsAllocationAdapterCreate (RsContext ctxWrapper, RsType vtype, RsAllocation baseAlloc) |
| { |
| return RS_DISPATCH(ctxWrapper, AllocationAdapterCreate, vtype, baseAlloc); |
| } |
| |
| extern "C" const void * rsaAllocationGetType(RsContext ctxWrapper, RsAllocation va) |
| { |
| return RS_DISPATCH(ctxWrapper, AllocationGetType, va); |
| } |
| |
| extern "C" RsNativeWindow rsAllocationGetSurface (RsContext ctxWrapper, RsAllocation alloc) |
| { |
| return RS_DISPATCH(ctxWrapper, AllocationGetSurface, alloc); |
| } |
| |
| extern "C" void rsAllocationSetupBufferQueue (RsContext ctxWrapper, RsAllocation alloc, uint32_t numAlloc) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationSetupBufferQueue, alloc, numAlloc); |
| } |
| |
| extern "C" void rsAllocationShareBufferQueue (RsContext ctxWrapper, RsAllocation alloc1, RsAllocation alloc2) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationShareBufferQueue, alloc1, alloc2); |
| } |
| |
| extern "C" void rsAllocationSetSurface (RsContext ctxWrapper, RsAllocation alloc, RsNativeWindow sur) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationSetSurface, alloc, sur); |
| } |
| |
| extern "C" void rsAllocationAdapterOffset (RsContext ctxWrapper, RsAllocation alloc, |
| const uint32_t * offsets, size_t offsets_length) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationAdapterOffset, alloc, offsets, offsets_length); |
| } |
| |
| extern "C" void rsAllocationCopyToBitmap (RsContext ctxWrapper, RsAllocation alloc, void * data, size_t data_length) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationCopyToBitmap, alloc, data, data_length); |
| } |
| |
| extern "C" void * rsAllocationGetPointer (RsContext ctxWrapper, RsAllocation va, uint32_t lod, RsAllocationCubemapFace face, |
| uint32_t z, uint32_t array, size_t * stride, size_t stride_length) |
| { |
| return RS_DISPATCH(ctxWrapper, AllocationGetPointer, va, lod, face, z, array, stride, stride_length); |
| } |
| |
| extern "C" void rsAllocation1DData (RsContext ctxWrapper, RsAllocation va, uint32_t xoff, uint32_t lod, uint32_t count, |
| const void * data, size_t data_length) |
| { |
| RS_DISPATCH(ctxWrapper, Allocation1DData, va, xoff, lod, count, data, data_length); |
| } |
| |
| extern "C" void rsAllocation1DElementData (RsContext ctxWrapper, RsAllocation va, uint32_t x, uint32_t lod, |
| const void * data, size_t data_length, size_t comp_offset) |
| { |
| RS_DISPATCH(ctxWrapper, Allocation1DElementData, va, x, lod, data, data_length, comp_offset); |
| } |
| |
| extern "C" void rsAllocationElementData (RsContext ctxWrapper, RsAllocation va, uint32_t x, uint32_t y, uint32_t z, |
| uint32_t lod, const void * data, size_t data_length, size_t comp_offset) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationElementData, va, x, y, z, lod, data, data_length, comp_offset); |
| } |
| |
| extern "C" void rsAllocation2DData (RsContext ctxWrapper, RsAllocation va, uint32_t xoff, uint32_t yoff, uint32_t lod, |
| RsAllocationCubemapFace face, uint32_t w, uint32_t h, |
| const void * data, size_t data_length, size_t stride) |
| { |
| RS_DISPATCH(ctxWrapper, Allocation2DData, va, xoff, yoff, lod, face, w, h, data, data_length, stride); |
| } |
| |
| extern "C" void rsAllocation3DData (RsContext ctxWrapper, RsAllocation va, 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 data_length, size_t stride) |
| { |
| RS_DISPATCH(ctxWrapper, Allocation3DData, va, xoff, yoff, zoff, lod, w, h, d, data, data_length, stride); |
| } |
| |
| extern "C" void rsAllocationGenerateMipmaps (RsContext ctxWrapper, RsAllocation va) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationGenerateMipmaps, va); |
| } |
| |
| extern "C" void rsAllocationRead (RsContext ctxWrapper, RsAllocation va, void * data, size_t data_length) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationRead, va, data, data_length); |
| } |
| |
| extern "C" void rsAllocation1DRead (RsContext ctxWrapper, RsAllocation va, uint32_t xoff, uint32_t lod, uint32_t count, |
| void * data, size_t data_length) |
| { |
| RS_DISPATCH(ctxWrapper, Allocation1DRead, va, xoff, lod, count, data, data_length); |
| } |
| |
| extern "C" void rsAllocationElementRead (RsContext ctxWrapper, RsAllocation va, uint32_t x, uint32_t y, uint32_t z, |
| uint32_t lod, void * data, size_t data_length, size_t comp_offset) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationElementRead, va, x, y, z, lod, data, data_length, comp_offset); |
| } |
| |
| extern "C" void rsAllocation2DRead (RsContext ctxWrapper, RsAllocation va, uint32_t xoff, uint32_t yoff, uint32_t lod, |
| RsAllocationCubemapFace face, uint32_t w, uint32_t h, |
| void * data, size_t data_length, size_t stride) |
| { |
| RS_DISPATCH(ctxWrapper, Allocation2DRead, va, xoff, yoff, lod, face, w, h, data, data_length, stride); |
| } |
| |
| extern "C" void rsAllocation3DRead (RsContext ctxWrapper, RsAllocation va, 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 data_length, size_t stride) |
| { |
| RS_DISPATCH(ctxWrapper, Allocation3DRead, va, xoff, yoff, zoff, lod, w, h, d, data, data_length, stride); |
| } |
| |
| extern "C" void rsAllocationSyncAll (RsContext ctxWrapper, RsAllocation va, RsAllocationUsageType src) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationSyncAll, va, src); |
| } |
| |
| extern "C" void rsAllocationResize1D (RsContext ctxWrapper, RsAllocation va, uint32_t dimX) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationResize1D, va, dimX); |
| } |
| |
| extern "C" void rsAllocationCopy2DRange (RsContext ctxWrapper, |
| RsAllocation dest, |
| uint32_t destXoff, uint32_t destYoff, |
| uint32_t destMip, uint32_t destFace, |
| uint32_t width, uint32_t height, |
| RsAllocation src, |
| uint32_t srcXoff, uint32_t srcYoff, |
| uint32_t srcMip, uint32_t srcFace) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationCopy2DRange, dest, destXoff, destYoff, destMip, destFace, |
| width, height, src, srcXoff, srcYoff, srcMip, srcFace); |
| } |
| |
| extern "C" void rsAllocationCopy3DRange (RsContext ctxWrapper, |
| RsAllocation dest, |
| uint32_t destXoff, uint32_t destYoff, uint32_t destZoff, |
| uint32_t destMip, |
| uint32_t width, uint32_t height, uint32_t depth, |
| RsAllocation src, |
| uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff, |
| uint32_t srcMip) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationCopy3DRange, |
| dest, destXoff, destYoff, destZoff, destMip, |
| width, height, depth, src, srcXoff, srcYoff, srcZoff, srcMip); |
| } |
| |
| extern "C" void rsAllocationIoSend (RsContext ctxWrapper, RsAllocation alloc) |
| { |
| RS_DISPATCH(ctxWrapper, AllocationIoSend, alloc); |
| } |
| |
| extern "C" int64_t rsAllocationIoReceive (RsContext ctxWrapper, RsAllocation alloc) |
| { |
| return RS_DISPATCH(ctxWrapper, AllocationIoReceive, alloc); |
| } |
| |
| // ScriptGroup |
| |
| extern "C" void rsScriptGroupExecute (RsContext ctxWrapper, RsScriptGroup group) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptGroupExecute, group); |
| } |
| |
| extern "C" RsScriptGroup2 rsScriptGroup2Create (RsContext ctxWrapper, const char * name, size_t name_length, |
| const char * cacheDir, size_t cacheDir_length, |
| RsClosure * closures, size_t closures_length) |
| { |
| return RS_DISPATCH(ctxWrapper, ScriptGroup2Create, |
| name, name_length, |
| cacheDir, cacheDir_length, |
| closures, closures_length); |
| } |
| |
| extern "C" RsClosure rsClosureCreate (RsContext ctxWrapper, RsScriptKernelID kernelID, RsAllocation returnValue, |
| RsScriptFieldID * fieldIDs, size_t fieldIDs_length, |
| const int64_t * values, size_t values_length, |
| const int * sizes, size_t sizes_length, |
| RsClosure * depClosures, size_t depClosures_length, |
| RsScriptFieldID * depFieldIDs, size_t depFieldIDs_length) |
| { |
| return RS_DISPATCH(ctxWrapper, ClosureCreate, kernelID, returnValue, fieldIDs, fieldIDs_length, |
| const_cast<int64_t *>(values), values_length, |
| const_cast<int *>(sizes), sizes_length, |
| depClosures, depClosures_length, depFieldIDs, depFieldIDs_length); |
| } |
| |
| extern "C" RsClosure rsInvokeClosureCreate (RsContext ctxWrapper, RsScriptInvokeID invokeID, |
| const void * params, size_t params_length, |
| const RsScriptFieldID * fieldIDs, size_t fieldIDs_length, |
| const int64_t * values, size_t values_length, |
| const int * sizes, size_t sizes_length) |
| { |
| return RS_DISPATCH(ctxWrapper, InvokeClosureCreate, invokeID, |
| params, params_length, |
| fieldIDs, fieldIDs_length, |
| values, values_length, |
| sizes, sizes_length); |
| } |
| |
| extern "C" void rsClosureSetArg (RsContext ctxWrapper, RsClosure closureID, uint32_t index, |
| uintptr_t value, int valueSize) |
| { |
| RS_DISPATCH(ctxWrapper, ClosureSetArg, closureID, index, value, valueSize); |
| } |
| |
| extern "C" void rsClosureSetGlobal (RsContext ctxWrapper, RsClosure closureID, RsScriptFieldID fieldID, |
| int64_t value, int valueSize) |
| { |
| RS_DISPATCH(ctxWrapper, ClosureSetGlobal, closureID, fieldID, value, valueSize); |
| } |
| |
| extern "C" RsScriptKernelID rsScriptKernelIDCreate (RsContext ctxWrapper, RsScript sid, int slot, int sig) |
| { |
| return RS_DISPATCH(ctxWrapper, ScriptKernelIDCreate, sid, slot, sig); |
| } |
| |
| extern "C" RsScriptFieldID rsScriptFieldIDCreate (RsContext ctxWrapper, RsScript sid, int slot) |
| { |
| return RS_DISPATCH(ctxWrapper, ScriptFieldIDCreate, sid, slot); |
| } |
| |
| extern "C" RsScriptGroup rsScriptGroupCreate (RsContext ctxWrapper, RsScriptKernelID * kernels, size_t kernels_length, |
| RsScriptKernelID * src, size_t src_length, |
| RsScriptKernelID * dstK, size_t dstK_length, |
| RsScriptFieldID * dstF, size_t dstF_length, |
| const RsType * type, size_t type_length) |
| { |
| return RS_DISPATCH(ctxWrapper, ScriptGroupCreate, |
| kernels, kernels_length, |
| src, src_length, dstK, dstK_length, |
| dstF, dstF_length, type, type_length); |
| } |
| |
| extern "C" void rsScriptGroupSetOutput (RsContext ctxWrapper, RsScriptGroup group, |
| RsScriptKernelID kernel, RsAllocation alloc) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptGroupSetOutput, group, kernel, alloc); |
| } |
| |
| extern "C" void rsScriptGroupSetInput (RsContext ctxWrapper, RsScriptGroup group, |
| RsScriptKernelID kernel, RsAllocation alloc) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptGroupSetInput, group, kernel, alloc); |
| } |
| |
| |
| // Sampler |
| extern "C" RsSampler rsSamplerCreate (RsContext ctxWrapper, RsSamplerValue magFilter, RsSamplerValue minFilter, |
| RsSamplerValue wrapS, RsSamplerValue wrapT, RsSamplerValue wrapR, |
| float mAniso) |
| { |
| return RS_DISPATCH(ctxWrapper, SamplerCreate, magFilter, minFilter, wrapS, wrapT, wrapR, mAniso); |
| } |
| |
| // Script |
| |
| extern "C" RsScript rsScriptCCreate (RsContext ctxWrapper, const char * resName, size_t resName_length, |
| const char * cacheDir, size_t cacheDir_length, |
| const char * text, size_t text_length) |
| { |
| return RS_DISPATCH(ctxWrapper, ScriptCCreate, resName, resName_length, cacheDir, cacheDir_length, text, text_length); |
| } |
| |
| extern "C" RsScript rsScriptIntrinsicCreate (RsContext ctxWrapper, uint32_t id, RsElement eid) |
| { |
| return RS_DISPATCH(ctxWrapper, ScriptIntrinsicCreate, id, eid); |
| } |
| |
| extern "C" void rsScriptBindAllocation (RsContext ctxWrapper, RsScript vtm, RsAllocation va, uint32_t slot) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptBindAllocation, vtm, va, slot); |
| } |
| |
| extern "C" void rsScriptSetTimeZone (RsContext ctxWrapper, RsScript s, const char * timeZone, size_t timeZone_length) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptSetTimeZone, s, timeZone, timeZone_length); |
| } |
| |
| extern "C" RsScriptInvokeID rsScriptInvokeIDCreate (RsContext ctxWrapper, RsScript s, uint32_t slot) |
| { |
| return RS_DISPATCH(ctxWrapper, ScriptInvokeIDCreate, s, slot); |
| } |
| |
| extern "C" void rsScriptInvoke (RsContext ctxWrapper, RsScript s, uint32_t slot) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptInvoke, s, slot); |
| } |
| |
| extern "C" void rsScriptInvokeV (RsContext ctxWrapper, RsScript s, uint32_t slot, const void * data, size_t data_length) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptInvokeV, s, slot, data, data_length); |
| } |
| |
| extern "C" void rsScriptForEach (RsContext ctxWrapper, RsScript s, uint32_t slot, |
| RsAllocation ain, RsAllocation aout, |
| const void * usr, size_t usr_length, |
| const RsScriptCall * sc, size_t sc_length) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptForEach, s, slot, ain, aout, usr, usr_length, sc, sc_length); |
| } |
| |
| extern "C" void rsScriptForEachMulti (RsContext ctxWrapper, RsScript s, uint32_t slot, |
| RsAllocation * ains, size_t ains_length, RsAllocation aout, |
| const void * usr, size_t usr_length, |
| const RsScriptCall * sc, size_t sc_length) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptForEachMulti, s, slot, ains, ains_length, aout, usr, usr_length, sc, sc_length); |
| } |
| |
| extern "C" void rsScriptReduce (RsContext ctxWrapper, RsScript s, uint32_t slot, |
| RsAllocation * ains, size_t ains_length, RsAllocation aout, |
| const RsScriptCall * sc, size_t sc_length) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptReduce, s, slot, ains, ains_length, aout, sc, sc_length); |
| } |
| |
| extern "C" void rsScriptSetVarI (RsContext ctxWrapper, RsScript s, uint32_t slot, int value) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptSetVarI, s, slot, value); |
| } |
| |
| extern "C" void rsScriptSetVarObj (RsContext ctxWrapper, RsScript s, uint32_t slot, RsObjectBase value) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptSetVarObj, s, slot, value); |
| } |
| |
| extern "C" void rsScriptSetVarJ (RsContext ctxWrapper, RsScript s, uint32_t slot, int64_t value) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptSetVarJ, s, slot, value); |
| } |
| |
| extern "C" void rsScriptSetVarF (RsContext ctxWrapper, RsScript s, uint32_t slot, float value) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptSetVarF, s, slot, value); |
| } |
| |
| extern "C" void rsScriptSetVarD (RsContext ctxWrapper, RsScript s, uint32_t slot, double value) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptSetVarD, s, slot, value); |
| } |
| |
| extern "C" void rsScriptSetVarV (RsContext ctxWrapper, RsScript s, uint32_t slot, |
| const void * data, size_t data_length) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptSetVarV, s, slot, data, data_length); |
| } |
| |
| extern "C" void rsScriptGetVarV (RsContext ctxWrapper, RsScript s, uint32_t slot, |
| void * data, size_t data_length) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptGetVarV, s, slot, data, data_length); |
| } |
| |
| extern "C" void rsScriptSetVarVE (RsContext ctxWrapper, RsScript s, uint32_t slot, |
| const void * data, size_t data_length, |
| RsElement e, const uint32_t * dims, size_t dims_length) |
| { |
| RS_DISPATCH(ctxWrapper, ScriptSetVarVE, s, slot, data, data_length, e, dims, dims_length); |
| } |
| |
| |
| // Graphics |
| /* The following API are deprecated. */ |
| |
| extern "C" RsContext rsContextCreateGL(RsDevice vdev, uint32_t version, uint32_t sdkVersion, |
| RsSurfaceConfig sc, uint32_t dpi) |
| { |
| if (!globalObjAlive) { |
| ALOGE("rsContextCreateGL is not allowed during process teardown."); |
| return nullptr; |
| } |
| |
| RsFallbackAdaptation& instance = RsFallbackAdaptation::GetInstance(); |
| RsContext context = instance.GetEntryFuncs()->ContextCreateGL(vdev, version, sdkVersion, sc, dpi); |
| |
| RsContextWrapper *ctxWrapper = new RsContextWrapper{context, instance.GetEntryFuncs()}; |
| |
| // Lock contextMap when adding new entries. |
| std::unique_lock<std::mutex> lock(contextMapMutex); |
| contextMap.insert(std::make_pair(context, ctxWrapper)); |
| |
| return (RsContext) ctxWrapper; |
| } |
| |
| extern "C" void rsContextBindProgramStore (RsContext ctxWrapper, RsProgramStore pgm) |
| { |
| RS_DISPATCH(ctxWrapper, ContextBindProgramStore, pgm); |
| } |
| |
| extern "C" void rsContextBindProgramFragment (RsContext ctxWrapper, RsProgramFragment pgm) |
| { |
| RS_DISPATCH(ctxWrapper, ContextBindProgramFragment, pgm); |
| } |
| |
| extern "C" void rsContextBindProgramVertex (RsContext ctxWrapper, RsProgramVertex pgm) |
| { |
| RS_DISPATCH(ctxWrapper, ContextBindProgramVertex, pgm); |
| } |
| |
| extern "C" void rsContextBindProgramRaster (RsContext ctxWrapper, RsProgramRaster pgm) |
| { |
| RS_DISPATCH(ctxWrapper, ContextBindProgramRaster, pgm); |
| } |
| |
| extern "C" void rsContextBindFont (RsContext ctxWrapper, RsFont pgm) |
| { |
| RS_DISPATCH(ctxWrapper, ContextBindFont, pgm); |
| } |
| |
| extern "C" void rsContextSetSurface (RsContext ctxWrapper, uint32_t width, uint32_t height, |
| RsNativeWindow sur) |
| { |
| RS_DISPATCH(ctxWrapper, ContextSetSurface, width, height, sur); |
| } |
| |
| extern "C" void rsContextBindRootScript (RsContext ctxWrapper, RsScript sampler) |
| { |
| RS_DISPATCH(ctxWrapper, ContextBindRootScript, sampler); |
| } |
| |
| extern "C" void rsContextPause (RsContext ctxWrapper) |
| { |
| RS_DISPATCH(ctxWrapper, ContextPause); |
| } |
| |
| extern "C" void rsContextResume (RsContext ctxWrapper) |
| { |
| RS_DISPATCH(ctxWrapper, ContextResume); |
| } |
| |
| extern "C" RsProgramStore rsProgramStoreCreate (RsContext ctxWrapper, |
| bool colorMaskR, bool colorMaskG, |
| bool colorMaskB, bool colorMaskA, |
| bool depthMask, bool ditherEnable, |
| RsBlendSrcFunc srcFunc, |
| RsBlendDstFunc destFunc, |
| RsDepthFunc depthFunc) |
| { |
| return RS_DISPATCH(ctxWrapper, ProgramStoreCreate, |
| colorMaskR, colorMaskG, colorMaskB, colorMaskA, |
| depthMask, ditherEnable, srcFunc, destFunc, depthFunc); |
| } |
| |
| extern "C" RsProgramRaster rsProgramRasterCreate (RsContext ctxWrapper, bool pointSprite, RsCullMode cull) |
| { |
| return RS_DISPATCH(ctxWrapper, ProgramRasterCreate, pointSprite, cull); |
| } |
| |
| extern "C" RsProgramFragment rsProgramFragmentCreate (RsContext ctxWrapper, |
| const char * shaderText, size_t shaderText_length, |
| const char ** textureNames, size_t textureNames_length_length, |
| const size_t * textureNames_length, |
| const uintptr_t * params, size_t params_length) |
| { |
| return RS_DISPATCH(ctxWrapper, ProgramFragmentCreate, |
| shaderText, shaderText_length, |
| textureNames, textureNames_length_length, textureNames_length, |
| params, params_length); |
| } |
| |
| extern "C" RsProgramVertex rsProgramVertexCreate (RsContext ctxWrapper, |
| const char * shaderText, size_t shaderText_length, |
| const char ** textureNames, size_t textureNames_length_length, |
| const size_t * textureNames_length, |
| const uintptr_t * params, size_t params_length) |
| { |
| return RS_DISPATCH(ctxWrapper, ProgramVertexCreate, |
| shaderText, shaderText_length, |
| textureNames, textureNames_length_length, textureNames_length, |
| params, params_length); |
| } |
| |
| extern "C" RsFont rsFontCreateFromFile (RsContext ctxWrapper, const char * name, size_t name_length, |
| float fontSize, uint32_t dpi) |
| { |
| return RS_DISPATCH(ctxWrapper, FontCreateFromFile, name, name_length, fontSize, dpi); |
| } |
| |
| extern "C" RsFont rsFontCreateFromMemory (RsContext ctxWrapper, const char * name, size_t name_length, |
| float fontSize, uint32_t dpi, |
| const void * data, size_t data_length) |
| { |
| return RS_DISPATCH(ctxWrapper, FontCreateFromMemory, name, name_length, fontSize, dpi, data, data_length); |
| } |
| |
| extern "C" RsMesh rsMeshCreate (RsContext ctxWrapper, RsAllocation * vtx, size_t vtx_length, |
| RsAllocation * idx, size_t idx_length, |
| uint32_t * primType, size_t primType_length) |
| { |
| return RS_DISPATCH(ctxWrapper, MeshCreate, vtx, vtx_length, idx, idx_length, primType, primType_length); |
| } |
| |
| extern "C" void rsProgramBindConstants (RsContext ctxWrapper, RsProgram vp, uint32_t slot, RsAllocation constants) |
| { |
| RS_DISPATCH(ctxWrapper, ProgramBindConstants, vp, slot, constants); |
| } |
| |
| extern "C" void rsProgramBindTexture (RsContext ctxWrapper, RsProgramFragment pf, uint32_t slot, RsAllocation a) |
| { |
| RS_DISPATCH(ctxWrapper, ProgramBindTexture, pf, slot,a); |
| } |
| |
| extern "C" void rsProgramBindSampler (RsContext ctxWrapper, RsProgramFragment pf, uint32_t slot, RsSampler s) |
| { |
| RS_DISPATCH(ctxWrapper, ProgramBindSampler, pf, slot, s); |
| } |
| |
| extern "C" RsObjectBase rsaFileA3DGetEntryByIndex(RsContext ctxWrapper, uint32_t index, RsFile file) |
| { |
| return RS_DISPATCH(ctxWrapper, FileA3DGetEntryByIndex, index, file); |
| } |
| |
| extern "C" RsFile rsaFileA3DCreateFromMemory(RsContext ctxWrapper, const void *data, uint32_t len) |
| { |
| return RS_DISPATCH(ctxWrapper, FileA3DCreateFromMemory, data, len); |
| } |
| |
| extern "C" RsFile rsaFileA3DCreateFromAsset(RsContext ctxWrapper, void *_asset) |
| { |
| return RS_DISPATCH(ctxWrapper, FileA3DCreateFromAsset, _asset); |
| } |
| |
| extern "C" RsFile rsaFileA3DCreateFromFile(RsContext ctxWrapper, const char *path) |
| { |
| return RS_DISPATCH(ctxWrapper, FileA3DCreateFromFile, path); |
| } |
| |
| extern "C" void rsaFileA3DGetNumIndexEntries(RsContext ctxWrapper, int32_t *numEntries, RsFile file) |
| { |
| RS_DISPATCH(ctxWrapper, FileA3DGetNumIndexEntries, numEntries, file); |
| } |
| |
| extern "C" void rsaFileA3DGetIndexEntries(RsContext ctxWrapper, RsFileIndexEntry *fileEntries, uint32_t numEntries, RsFile file) |
| { |
| RS_DISPATCH(ctxWrapper, FileA3DGetIndexEntries, fileEntries, numEntries, file); |
| } |
| |
| extern "C" void rsaMeshGetVertexBufferCount(RsContext ctxWrapper, RsMesh mv, int32_t *numVtx) |
| { |
| RS_DISPATCH(ctxWrapper, MeshGetVertexBufferCount, mv, numVtx); |
| } |
| |
| extern "C" void rsaMeshGetIndexCount(RsContext ctxWrapper, RsMesh mv, int32_t *numIdx) |
| { |
| RS_DISPATCH(ctxWrapper, MeshGetIndexCount, mv, numIdx); |
| } |
| |
| extern "C" void rsaMeshGetVertices(RsContext ctxWrapper, RsMesh mv, RsAllocation *vtxData, uint32_t vtxDataCount) |
| { |
| RS_DISPATCH(ctxWrapper, MeshGetVertices, mv, vtxData, vtxDataCount); |
| } |
| |
| extern "C" void rsaMeshGetIndices(RsContext ctxWrapper, RsMesh mv, RsAllocation *va, uint32_t *primType, uint32_t idxDataCount) |
| { |
| RS_DISPATCH(ctxWrapper, MeshGetIndices, mv, va, primType, idxDataCount); |
| } |
