You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
912 lines
36 KiB
912 lines
36 KiB
/*
|
|
* 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);
|
|
}
|